render/render-ws-java-client/src/main/java/org/janelia/render/client/ValidateTilesClient.java at master · perlman/render · GitHub

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
package org.janelia.render.client;

import com.beust.jcommander.Parameter;
import com.beust.jcommander.ParametersDelegate;

import java.io.IOException;
import java.util.List;

import org.janelia.alignment.spec.ResolvedTileSpecCollection;
import org.janelia.alignment.spec.stack.StackMetaData;
import org.janelia.alignment.spec.validator.TileSpecValidator;
import org.janelia.render.client.parameter.CommandLineParameters;
import org.janelia.render.client.parameter.RenderWebServiceParameters;
import org.janelia.render.client.parameter.TileSpecValidatorParameters;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

/**
 * Java client for validating tiles in a stack.
 *
 * @author Eric Trautman
 */
public class ValidateTilesClient {

    public static class Parameters extends CommandLineParameters {

        @ParametersDelegate
        public RenderWebServiceParameters renderWeb = new RenderWebServiceParameters();

        @ParametersDelegate
        public TileSpecValidatorParameters tileSpecValidator = new TileSpecValidatorParameters();


        @Parameter(
                names = "--stack",
                description = "Stack name",
                required = true)
        public String stack;

        @Parameter(
                names = "--removeInvalidTiles",
                description = "If invalid tiles are found, remove them",
                arity = 0)
        public boolean removeInvalidTiles = false;

        @Parameter(
                names = "--completeStackAfterRemoval",
                description = "If invalid tiles have been removed, complete the stack after removal",
                arity = 0)
        public boolean completeStackAfterRemoval = false;

        @Parameter(
                description = "Z values",
                required = true)
        public List<String> zValues;
    }

    public static void main(final String[] args) {
        final ClientRunner clientRunner = new ClientRunner(args) {
            @Override
            public void runClient(final String[] args) throws Exception {

                final Parameters parameters = new Parameters();
                parameters.parse(args);

                LOG.info("runClient: entry, parameters={}", parameters);

                final ValidateTilesClient client = new ValidateTilesClient(parameters);
                for (final String z : parameters.zValues) {
                    client.validateTilesForZ(new Double(z));
                }
                client.completeStackIfNecessary();
            }
        };
        clientRunner.run();
    }

    private final Parameters parameters;
    private final TileSpecValidator tileSpecValidator;
    private int totalTilesRemoved;

    private final RenderDataClient renderDataClient;

    private ValidateTilesClient(final Parameters parameters) {
        this.parameters = parameters;
        this.tileSpecValidator = parameters.tileSpecValidator.getValidatorInstance();
        this.totalTilesRemoved = 0;

        this.renderDataClient = parameters.renderWeb.getDataClient();
    }

    private void validateTilesForZ(final Double z)
            throws Exception {

        LOG.info("validateTilesForZ: entry, z={}", z);

        final ResolvedTileSpecCollection tiles = renderDataClient.getResolvedTiles(parameters.stack, z);

        // resolve all tile specs before validating
        tiles.resolveTileSpecs();

        final int totalNumberOfTiles = tiles.getTileCount();
        if (tileSpecValidator != null) {
            tiles.setTileSpecValidator(tileSpecValidator);
            tiles.removeInvalidTileSpecs();
        }

        final int numberOfRemovedTiles = totalNumberOfTiles - tiles.getTileCount();

        if (parameters.removeInvalidTiles && (numberOfRemovedTiles > 0)) {
            if (totalTilesRemoved == 0) {
                renderDataClient.ensureStackIsInLoadingState(parameters.stack, null);
            }
            renderDataClient.deleteStack(parameters.stack, z);              // remove existing tiles for layer
            renderDataClient.saveResolvedTiles(tiles, parameters.stack, z); // and replace with good tiles
            totalTilesRemoved += numberOfRemovedTiles;
        }

        LOG.info("validateTilesForZ: {} out of {} tiles for z {} are invalid",
                 numberOfRemovedTiles, totalNumberOfTiles, z);
    }

    private void completeStackIfNecessary()
            throws IOException {
        if (parameters.completeStackAfterRemoval && (totalTilesRemoved > 0)) {
            renderDataClient.setStackState(parameters.stack, StackMetaData.StackState.COMPLETE);
        }
    }

    private static final Logger LOG = LoggerFactory.getLogger(ValidateTilesClient.class);
}