Examples with Interval ca.nrc.cadc.caom2.types.Interval used on opensource projects

Example 1 with Interval

use of ca.nrc.cadc.caom2.types.Interval in project caom2db by opencadc.

the class PostgreSQLGenerator method getSubIntervalList.

@Override
protected List<Interval> getSubIntervalList(ResultSet rs, int col) throws SQLException {
    String s = rs.getString(col);
    if (s == null) {
        return null;
    }
    PgInterval pgi = new PgInterval();
    ca.nrc.cadc.dali.DoubleInterval[] dis = pgi.getIntervalArray(s);
    List<Interval> ret = new ArrayList<Interval>();
    for (ca.nrc.cadc.dali.DoubleInterval di : dis) {
        ret.add(new Interval(di.getLower(), di.getUpper()));
    }
    return ret;
}

Example 2 with Interval

use of ca.nrc.cadc.caom2.types.Interval in project caom2db by opencadc.

the class PostgreSQLGenerator method safeSetSubIntervalList.

/**
 * Store a list of intervals in a polygon column.
 *
 * @param sb
 * @param ps
 * @param col
 * @param subs
 * @throws SQLException
 */
@Override
protected void safeSetSubIntervalList(StringBuilder sb, PreparedStatement ps, int col, List<Interval> subs) throws SQLException {
    if (subs == null || subs.isEmpty()) {
        ps.setObject(col, null);
        if (sb != null) {
            sb.append("null,");
        }
    } else {
        log.debug("[safeSetSubIntervalList] in: " + subs.size() + " Intervals");
        ca.nrc.cadc.dali.DoubleInterval[] dis = new ca.nrc.cadc.dali.DoubleInterval[subs.size()];
        int i = 0;
        for (Interval si : subs) {
            dis[i++] = new ca.nrc.cadc.dali.DoubleInterval(si.getLower(), si.getUpper());
        }
        PgInterval pgi = new PgInterval();
        PGpolygon poly = pgi.generatePolygon2D(dis);
        ps.setObject(col, poly);
        if (sb != null) {
            sb.append(poly.getValue());
            sb.append(",");
        }
    }
}

Example 3 with Interval

use of ca.nrc.cadc.caom2.types.Interval in project caom2db by opencadc.

the class AbstractObservationDAOTest method getTestPlane.

protected Plane getTestPlane(boolean full, String productID, int depth, boolean poly) throws Exception {
    Plane p = new Plane(productID);
    if (full) {
        p.metaProducer = URI.create("test:plane/roundrip-1.0");
        p.creatorID = URI.create("ivo://example.com/TEST?" + productID);
        p.calibrationLevel = CalibrationLevel.CALIBRATED;
        p.dataProductType = DataProductType.IMAGE;
        p.metaRelease = TEST_DATE;
        p.dataRelease = TEST_DATE;
        p.provenance = new Provenance("doit");
        p.provenance.lastExecuted = TEST_DATE;
        p.provenance.producer = "MyProducer";
        p.provenance.project = "MyProject";
        p.provenance.reference = new URI("http://www.example.com/MyProject/doit");
        p.provenance.runID = "RUNID123";
        p.provenance.version = "0.1alpha4";
        p.provenance.getKeywords().addAll(TEST_KEYWORDS);
        p.provenance.getInputs().add(new PlaneURI(new ObservationURI("FOO", "bar"), "in1"));
        p.provenance.getInputs().add(new PlaneURI(new ObservationURI("FOO", "bar"), "in2"));
        p.metrics = new Metrics();
        p.metrics.sourceNumberDensity = 100.0;
        p.metrics.background = 2.7;
        p.metrics.backgroundStddev = 0.3;
        p.metrics.fluxDensityLimit = 1.0e-5;
        p.metrics.magLimit = 28.5;
        p.metrics.sampleSNR = 11.0;
        p.quality = new DataQuality(Quality.JUNK);
        // previously was computed metadata
        p.energy = new Energy();
        p.energy.bandpassName = "V";
        p.energy.bounds = new SampledInterval(400e-6, 900e-6);
        p.energy.bounds.getSamples().add(new Interval(400e-6, 500e-6));
        p.energy.bounds.getSamples().add(new Interval(800e-6, 900e-6));
        p.energy.dimension = 2L;
        p.energy.getEnergyBands().add(EnergyBand.OPTICAL);
        p.energy.resolvingPower = 2.0;
        p.energy.resolvingPowerBounds = new Interval(1.8, 2.2);
        p.energy.restwav = 600e-9;
        p.energy.sampleSize = 100e-6;
        p.energy.transition = new EnergyTransition("H", "alpha");
        p.polarization = new Polarization();
        p.polarization.dimension = 3L;
        p.polarization.states = new TreeSet<>();
        p.polarization.states.add(PolarizationState.I);
        p.polarization.states.add(PolarizationState.Q);
        p.polarization.states.add(PolarizationState.U);
        p.position = new Position();
        if (poly) {
            MultiPolygon mp = new MultiPolygon();
            mp.getVertices().add(new Vertex(2.0, 2.0, SegmentType.MOVE));
            mp.getVertices().add(new Vertex(1.0, 4.0, SegmentType.LINE));
            mp.getVertices().add(new Vertex(3.0, 3.0, SegmentType.LINE));
            mp.getVertices().add(new Vertex(0.0, 0.0, SegmentType.CLOSE));
            List<Point> points = new ArrayList<Point>();
            for (Vertex v : mp.getVertices()) {
                if (!SegmentType.CLOSE.equals(v.getType())) {
                    points.add(new Point(v.cval1, v.cval2));
                }
            }
            p.position.bounds = new Polygon(points, mp);
        } else {
            p.position.bounds = new Circle(new Point(0.0, 89.0), 2.0);
        }
        p.position.dimension = new Dimension2D(1024, 2048);
        p.position.resolution = 0.05;
        p.position.resolutionBounds = new Interval(0.04, 0.06);
        p.position.sampleSize = 0.025;
        p.position.timeDependent = false;
        p.time = new Time();
        p.time.bounds = new SampledInterval(50000.25, 50000.75);
        p.time.bounds.getSamples().add(new Interval(50000.25, 50000.40));
        p.time.bounds.getSamples().add(new Interval(50000.50, 50000.75));
        p.time.dimension = 2L;
        p.time.exposure = 666.0;
        p.time.resolution = 0.5;
        p.time.resolutionBounds = new Interval(0.22, 0.88);
        p.time.sampleSize = 0.15;
        p.custom = new CustomAxis("FDEP");
        p.custom.bounds = new SampledInterval(100.0, 200.0);
        p.custom.bounds.getSamples().add(new Interval(100.0, 140.0));
        p.custom.bounds.getSamples().add(new Interval(160.0, 200.0));
        p.custom.bounds.validate();
        p.custom.dimension = 1024L;
        p.observable = new Observable("phot.flux");
        p.getMetaReadGroups().add(URI.create("ivo://example.net/gms?GroupA"));
        p.getMetaReadGroups().add(URI.create("ivo://example.net/gms?GroupB"));
        p.getDataReadGroups().add(URI.create("ivo://example.net/gms?GroupC"));
        p.getDataReadGroups().add(URI.create("ivo://example.net/gms?GroupD"));
    }
    if (depth <= 2)
        return p;
    p.getArtifacts().add(getTestArtifact(full, new URI("http://www.example.com/stuff/" + productID + "a"), depth));
    p.getArtifacts().add(getTestArtifact(full, new URI("http://www.example.com/stuff/" + productID + "b"), depth));
    Assert.assertEquals(2, p.getArtifacts().size());
    return p;
}

Example 4 with Interval

use of ca.nrc.cadc.caom2.types.Interval in project caom2db by opencadc.

the class AbstractObservationDAOTest method testEqual.

private void testEqual(Plane expected, Plane actual) {
    testEntity(expected, actual);
    Assert.assertEquals("productID", expected.getProductID(), actual.getProductID());
    Assert.assertEquals("creatorID", expected.creatorID, actual.creatorID);
    Assert.assertEquals("calibrationLevel", expected.calibrationLevel, actual.calibrationLevel);
    Assert.assertEquals("dataProductType", expected.dataProductType, actual.dataProductType);
    testEqualSeconds("plane.metaRelease", expected.metaRelease, actual.metaRelease);
    testEqualSeconds("plane.dataRelease", expected.dataRelease, actual.dataRelease);
    if (expected.provenance != null) {
        Assert.assertEquals("provenance.name", expected.provenance.getName(), actual.provenance.getName());
        Assert.assertEquals("provenance.reference", expected.provenance.reference, actual.provenance.reference);
        Assert.assertEquals("provenance.version", expected.provenance.version, actual.provenance.version);
        Assert.assertEquals("provenance.project", expected.provenance.project, actual.provenance.project);
        Assert.assertEquals("provenance.producer", expected.provenance.producer, actual.provenance.producer);
        Assert.assertEquals("provenance.runID", expected.provenance.runID, actual.provenance.runID);
        testEqualSeconds("provenance.lastExecuted", expected.provenance.lastExecuted, actual.provenance.lastExecuted);
        Assert.assertEquals("provenance.inputs", expected.provenance.getInputs(), actual.provenance.getInputs());
        testEqual("provenance.keywords", expected.provenance.getKeywords(), actual.provenance.getKeywords());
    } else
        Assert.assertNull(actual.provenance);
    if (expected.metrics != null) {
        Assert.assertEquals("metrics.sourceNumberDensity", expected.metrics.sourceNumberDensity, actual.metrics.sourceNumberDensity);
        Assert.assertEquals("metrics.background", expected.metrics.background, actual.metrics.background);
        Assert.assertEquals("metrics.backgroundStdde", expected.metrics.backgroundStddev, actual.metrics.backgroundStddev);
        Assert.assertEquals("metrics.fluxDensityLimit", expected.metrics.fluxDensityLimit, actual.metrics.fluxDensityLimit);
        Assert.assertEquals("metrics.magLimit", expected.metrics.magLimit, actual.metrics.magLimit);
    } else
        Assert.assertNull(actual.metrics);
    if (expected.position != null) {
        Assert.assertNotNull("plane.position", actual.position);
        if (expected.position.bounds != null && Polygon.class.equals(expected.position.bounds.getClass())) {
            Polygon ep = (Polygon) expected.position.bounds;
            Polygon ap = (Polygon) actual.position.bounds;
            Assert.assertEquals("num points", ep.getPoints().size(), ap.getPoints().size());
            for (int i = 0; i < ep.getPoints().size(); i++) {
                Point ept = ep.getPoints().get(i);
                Point apt = ap.getPoints().get(i);
                Assert.assertEquals("point.cval1", ept.cval1, apt.cval1, 0.0);
                Assert.assertEquals("point.cval2", ept.cval2, apt.cval2, 0.0);
            }
            Assert.assertEquals("num vertices", ep.getSamples().getVertices().size(), ap.getSamples().getVertices().size());
            for (int i = 0; i < ep.getSamples().getVertices().size(); i++) {
                Vertex ev = ep.getSamples().getVertices().get(i);
                Vertex av = ap.getSamples().getVertices().get(i);
                Assert.assertEquals("vertex.cval2", ev.getType(), av.getType());
                Assert.assertEquals("vertex.cval1", ev.cval1, av.cval1, 0.0);
                Assert.assertEquals("vertex.cval2", ev.cval2, av.cval2, 0.0);
            }
        } else if (expected.position.bounds != null && Circle.class.equals(expected.position.bounds.getClass())) {
            Circle ep = (Circle) expected.position.bounds;
            Circle ap = (Circle) actual.position.bounds;
            Assert.assertEquals("center.cval1", ep.getCenter().cval1, ap.getCenter().cval1, 0.0);
            Assert.assertEquals("center.cval2", ep.getCenter().cval2, ap.getCenter().cval2, 0.0);
            Assert.assertEquals("radius", ep.getRadius(), ap.getRadius(), 0.0);
        } else
            Assert.assertNull(actual.position.bounds);
        if (expected.position.dimension != null) {
            Assert.assertEquals("position.dimension.naxis1", expected.position.dimension.naxis1, actual.position.dimension.naxis1);
            Assert.assertEquals("position.dimension.naxis2", expected.position.dimension.naxis2, actual.position.dimension.naxis2);
        } else
            Assert.assertNull(actual.position.dimension);
        Assert.assertEquals("position.resolution", expected.position.resolution, actual.position.resolution);
        Assert.assertEquals("position.sampleSize", expected.position.sampleSize, actual.position.sampleSize);
        Assert.assertEquals("position.timeDependent", expected.position.timeDependent, actual.position.timeDependent);
    }
    if (expected.energy != null) {
        Assert.assertNotNull("plane.energy", actual.energy);
        if (expected.energy.bounds != null) {
            Assert.assertNotNull("energy.bounds", actual.energy.bounds);
            Assert.assertEquals("energy.bounds.lower", expected.energy.bounds.getLower(), actual.energy.bounds.getLower(), 0.0);
            Assert.assertEquals("energy.bounds.upper", expected.energy.bounds.getUpper(), actual.energy.bounds.getUpper(), 0.0);
            Assert.assertEquals("energy.bounds.samples.size", expected.energy.bounds.getSamples().size(), actual.energy.bounds.getSamples().size());
            for (int i = 0; i < expected.energy.bounds.getSamples().size(); i++) {
                Interval esi = expected.energy.bounds.getSamples().get(i);
                Interval asi = actual.energy.bounds.getSamples().get(i);
                Assert.assertEquals("SubInterval.lb", esi.getLower(), asi.getLower(), 0.0);
                Assert.assertEquals("SubInterval.ub", esi.getUpper(), asi.getUpper(), 0.0);
            }
        } else
            Assert.assertNull("energy.bounds", actual.energy.bounds);
        Assert.assertEquals("energy.bandpassName", expected.energy.bandpassName, actual.energy.bandpassName);
        Assert.assertEquals("energy.dimension", expected.energy.dimension, actual.energy.dimension);
        Iterator<EnergyBand> ee = expected.energy.getEnergyBands().iterator();
        Iterator<EnergyBand> ae = actual.energy.getEnergyBands().iterator();
        while (ee.hasNext()) {
            EnergyBand ex = ee.next();
            EnergyBand ac = ae.next();
            Assert.assertEquals("energy.energyBand", ex, ac);
        }
        Assert.assertEquals("energy.resolvingPower", expected.energy.resolvingPower, actual.energy.resolvingPower);
        Assert.assertEquals("energy.restwav", expected.energy.restwav, actual.energy.restwav);
        Assert.assertEquals("energy.sampleSize", expected.energy.sampleSize, actual.energy.sampleSize);
        Assert.assertEquals("energy.transition", expected.energy.transition, actual.energy.transition);
    }
    if (expected.time != null) {
        Assert.assertNotNull("plane.time", actual.time);
        if (expected.time.bounds != null) {
            Assert.assertNotNull("time.bounds", actual.time.bounds);
            Assert.assertEquals("time.bounds.lower", expected.time.bounds.getLower(), actual.time.bounds.getLower(), 0.0);
            Assert.assertEquals("time.bounds.upper", expected.time.bounds.getUpper(), actual.time.bounds.getUpper(), 0.0);
            Assert.assertEquals("time.bounds.samples.size", expected.time.bounds.getSamples().size(), actual.time.bounds.getSamples().size());
            for (int i = 0; i < expected.time.bounds.getSamples().size(); i++) {
                Interval esi = expected.time.bounds.getSamples().get(i);
                Interval asi = actual.time.bounds.getSamples().get(i);
                Assert.assertEquals("SubInterval.lb", esi.getLower(), asi.getLower(), 0.0);
                Assert.assertEquals("SubInterval.ub", esi.getUpper(), asi.getUpper(), 0.0);
            }
        } else
            Assert.assertNull("time.bounds", actual.time.bounds);
        Assert.assertEquals("time.dimension", expected.time.dimension, actual.time.dimension);
        Assert.assertEquals("time.exposure", expected.time.exposure, actual.time.exposure);
        Assert.assertEquals("time.resolution", expected.time.resolution, actual.time.resolution);
        Assert.assertEquals("time.sampleSize", expected.time.sampleSize, actual.time.sampleSize);
    }
    if (expected.polarization != null) {
        Assert.assertNotNull("plane.polarization", actual.polarization);
        if (expected.polarization.states != null) {
            Assert.assertNotNull("polarization.states", actual.polarization.states);
            Assert.assertEquals("polarization.states.size", expected.polarization.states.size(), actual.polarization.states.size());
            Iterator<PolarizationState> ei = expected.polarization.states.iterator();
            Iterator<PolarizationState> ai = actual.polarization.states.iterator();
            while (ei.hasNext()) {
                Assert.assertEquals("polarization.state", ei.next(), ai.next());
            }
            Assert.assertEquals("polarization.dimension", expected.polarization.dimension, actual.polarization.dimension);
        }
    }
    Assert.assertEquals("metaReadGroups.size", expected.getMetaReadGroups().size(), actual.getMetaReadGroups().size());
    Iterator<URI> emra = expected.getMetaReadGroups().iterator();
    Iterator<URI> amra = actual.getMetaReadGroups().iterator();
    while (emra.hasNext() || amra.hasNext()) {
        Assert.assertEquals(emra.next(), amra.next());
    }
    Assert.assertEquals("dataReadGroups.size", expected.getMetaReadGroups().size(), actual.getMetaReadGroups().size());
    Iterator<URI> edra = expected.getDataReadGroups().iterator();
    Iterator<URI> adra = actual.getDataReadGroups().iterator();
    while (edra.hasNext() || adra.hasNext()) {
        Assert.assertEquals(edra.next(), adra.next());
    }
    log.debug("num artifacts: " + expected.getArtifacts().size() + " == " + actual.getArtifacts().size());
    Assert.assertEquals("number of artifacts", expected.getArtifacts().size(), actual.getArtifacts().size());
    Iterator<Artifact> ea = expected.getArtifacts().iterator();
    Iterator<Artifact> aa = actual.getArtifacts().iterator();
    while (ea.hasNext()) {
        Artifact ex = ea.next();
        Artifact ac = aa.next();
        testEqual(ex, ac);
    }
    testEntityChecksums(expected, actual);
}