dive4elements/river: flys-artifacts/src/main/java/de/intevation/flys/artifacts/model/FixingsOverview.java comparison

comparison flys-artifacts/src/main/java/de/intevation/flys/artifacts/model/FixingsOverview.java @ 2562:ba35dfb7c09a

FixingsOverview: Construct the Q sectors once. flys-artifacts/trunk@4088 c6561f87-3c4e-4783-a992-168aeb5c3f6f

author	Sascha L. Teichmann <sascha.teichmann@intevation.de>
date	Mon, 20 Feb 2012 14:36:28 +0000
parents	b3f6d49cdc80
children	59c920e73d8a

comparison

equal deleted inserted replaced

-:b3f6d49cdc80
+:ba35dfb7c09a
 "SELECT" +
 "    MIN(position) AS start_km," +
 "    MAX(position) AS stop_km " +
 "FROM" +
 "    wst_column_values " +
-"WHERE " +
+"WHERE" +
 "    wst_column_id = :column_id";
 public static class Range implements Serializable {
 protected double start;
 public Range(double start, double end) {
 this.start = start;
 this.end   = end;
 }
+public double getStart() {
+return start;
+}
+public double getEnd() {
+return end;
+}
 public boolean disjoint(Range other) {
 return start > other.end || other.start > end;
+}
+public boolean intersects(Range other) {
+return !disjoint(other);
 }
 public boolean clip(Range other) {
 if (disjoint(other)) return false;
 }
 return sectors.size();
 }
 } // class GaugeRange
+public static class GaugeFinder {
+protected List<GaugeRange> gauges;
+protected boolean          isKmUp;
+public GaugeFinder(List<GaugeRange> gauges) {
+this(gauges, true);
+}
+public GaugeFinder(
+List<GaugeRange> gauges,
+boolean          isKmUp
+) {
+this.gauges = gauges;
+this.isKmUp = isKmUp;
+}
+public boolean getIsKmUp() {
+return isKmUp;
+}
+public void setIsKmUp(boolean isKmUp) {
+this.isKmUp = isKmUp;
+}
+public GaugeRange find(Range range) {
+double km = isKmUp ? range.start : range.end;
+for (GaugeRange gauge: gauges) {
+if (gauge.inside(km)) {
+return gauge;
+}
+}
+return null;
+}
+public GaugeRange find(int gaugeId) {
+for (GaugeRange gauge: gauges) {
+if (gauge.gaugeId == gaugeId) {
+return gauge;
+}
+}
+return null;
+}
+public boolean loadDischargeSectors(Session session, int riverId) {
+SQLQuery query = session.createSQLQuery(SQL_DISCHARGE_SECTORS)
+.addScalar("gauge_id", StandardBasicTypes.INTEGER)
+.addScalar("name",     StandardBasicTypes.STRING)
+.addScalar("value",    StandardBasicTypes.DOUBLE);
+query.setInteger("river_id", riverId);
+List<Object []> list = query.list();
+if (list.isEmpty()) {
+log.warn("River " + riverId + " has no discharge sectors.");
+return false;
+}
+GaugeRange gauge = null;
+for (Object [] row: list) {
+int    gaugeId = (Integer)row[0];
+String label   = (String) row[1];
+Double value   = (Double) row[2];
+if (gauge == null || gauge.gaugeId != gaugeId) {
+if ((gauge = find(gaugeId)) == null) {
+log.warn("Cannot find gauge for id " + gaugeId + ".");
+continue;
+}
+}
+gauge.addMainValue(label, value);
+}
+for (GaugeRange g: gauges) {
+g.buildClasses();
+}
+return true;
+}
+} // class GaugeFinder
 public static class QRange extends Range {
 protected double q;
 public QRange() {
 protected int sector;
 public SectorRange() {
 }
+public SectorRange(SectorRange other) {
+start  = other.start;
+end    = other.end;
+sector = other.sector;
+}
 public SectorRange(double start, double end, int sector) {
 super(start, end);
 this.sector = sector;
+}
+public int getSector() {
+return sector;
 }
 public boolean enlarge(SectorRange other) {
 if (sector == other.sector
 && Math.abs(end-other.start) < EPSILON2) {
 protected int    columnId;
 protected Date   startTime;
 protected String name;
-protected List<QRange> qRanges;
+protected List<SectorRange> sectors;
 public Column() {
 }
 public Column(int columnId, Date startTime, String name) {
 this.columnId  = columnId;
 this.startTime = startTime;
 this.name      = name;
-qRanges = new ArrayList<QRange>();
+sectors = new ArrayList<SectorRange>();
 }
 public Fixing getFixing() {
 return Fixing.this;
 }
-public List<SectorRange> classify(GaugeRange gauge) {
+public List<SectorRange> getSectors() {
+return sectors;
-List<SectorRange> sectors = new ArrayList<SectorRange>();
+}
+public void buildSectors(GaugeRange gauge, List<QRange> qRanges) {
 for (QRange qRange: qRanges) {
 SectorRange sector = new SectorRange(
 qRange.start, qRange.end,
 gauge.classify(qRange.q));
 if (sectors.isEmpty()
 || !sectors.get(sectors.size()-1).enlarge(sector)) {
 sectors.add(sector);
 }
 }
-return sectors;
 }
 public void loadKmRange(SQLQuery query) {
 query.setInteger("column_id", columnId);
 start = (Double)obj[0];
 end   = (Double)obj[1];
 }
 }
-public void loadQRanges(SQLQuery query) {
+public void loadQRanges(
+SQLQuery    query,
+GaugeFinder gaugeFinder
+) {
 query.setInteger("column_id", columnId);
 List<Object []> list = query.list();
+List<QRange> qRanges = new ArrayList<QRange>(list.size());
 for (Object [] row: list) {
 double q     = (Double)row[0];
 double start = (Double)row[1];
 double end   = (Double)row[2];
 QRange qRange = new QRange(start, end, q);
 if (qRange.clip(this)) {
 qRanges.add(qRange);
 }
 }
+GaugeRange gauge = gaugeFinder.find(this);
+if (gauge != null) {
+buildSectors(gauge, qRanges);
+}
+else {
+log.warn("No gauge found for column " + columnId + ".");
+}
 }
 } // class Column
-protected int                wstId;
+protected int          wstId;
-protected String             description;
+protected String       description;
 protected List<Column> columns;
 public Fixing() {
 }
 for (Column column: columns) {
 column.loadKmRange(query);
 }
 }
-public void loadColumnsQRanges(SQLQuery query) {
+public void loadColumnsQRanges(
+SQLQuery    query,
+GaugeFinder gaugeFinder
+) {
 for (Column column: columns) {
-column.loadQRanges(query);
+column.loadQRanges(query, gaugeFinder);
 }
 }
-public void addAllColumns(List<Column> allColumns) {
+public void addAllColumns(List<Column> allColumns, Range range) {
-allColumns.addAll(columns);
+for (Column column: columns) {
+if (column.intersects(range)) {
+allColumns.add(column);
+}
+}
 }
 } // class Fixing
-protected String           riverName;
+protected String       riverName;
-protected int              riverId;
+protected int          riverId;
-protected boolean          isKmUp;
+protected boolean      isKmUp;
-protected List<GaugeRange> gauges;
+protected List<Fixing> fixings;
-protected List<Fixing>     fixings;
+protected Range        extent;
-protected Range            extent;
 public FixingsOverview() {
-gauges  = new ArrayList<GaugeRange>();
 fixings = new ArrayList<Fixing>();
 }
 public FixingsOverview(String riverName) {
 this();
 extent = new Range((Double)row[0], (Double)row[1]);
 return true;
 }
+protected GaugeFinder loadGauges(Session session) {
-protected boolean loadGauges(Session session) {
 SQLQuery query = session.createSQLQuery(SQL_GAUGES)
 .addScalar("gauge_id", StandardBasicTypes.INTEGER)
 .addScalar("a",        StandardBasicTypes.DOUBLE)
 .addScalar("b",        StandardBasicTypes.DOUBLE);
 List<Object []> list = query.list();
 if (list.isEmpty()) {
 log.warn("River " + riverId + " has no gauges.");
-return false;
+return null;
 }
+List<GaugeRange> gauges = new ArrayList<GaugeRange>();
 for (Object [] row: list) {
 int    gaugeId = (Integer)row[0];
 double start   = (Double) row[1];
 double end     = (Double) row[2];
 GaugeRange gauge = new GaugeRange(start, end, gaugeId);
 gauges.add(gauge);
 }
-return true;
+return new GaugeFinder(gauges, isKmUp);
 }
-protected GaugeRange findGaugeById(int gaugeId) {
-for (GaugeRange gauge: gauges) {
-if (gauge.gaugeId == gaugeId) {
-return gauge;
-}
-}
-return null;
-}
-protected GaugeRange findGaugeByKm(double km) {
-for (GaugeRange gauge: gauges) {
-if (gauge.inside(km)) {
-return gauge;
-}
-}
-return null;
-}
-protected boolean loadDischargeSectors(Session session) {
-SQLQuery query = session.createSQLQuery(SQL_DISCHARGE_SECTORS)
-.addScalar("gauge_id", StandardBasicTypes.INTEGER)
-.addScalar("name",     StandardBasicTypes.STRING)
-.addScalar("value",    StandardBasicTypes.DOUBLE);
-query.setInteger("river_id", riverId);
-List<Object []> list = query.list();
-if (list.isEmpty()) {
-log.warn("River " + riverId + " has no discharge sectors.");
-return false;
-}
-GaugeRange gauge = null;
-for (Object [] row: list) {
-int    gaugeId = (Integer)row[0];
-String label   = (String) row[1];
-Double value   = (Double) row[2];
-if (gauge == null || gauge.gaugeId != gaugeId) {
-if ((gauge = findGaugeById(gaugeId)) == null) {
-log.warn("Cannot find gauge for id " + gaugeId + ".");
-continue;
-}
-}
-gauge.addMainValue(label, value);
-}
-for (GaugeRange g: gauges) {
-g.buildClasses();
-}
-return true;
-}
 protected void loadFixings(Session session) {
 SQLQuery query = session.createSQLQuery(SQL_FIXINGS)
 .addScalar("wst_id",      StandardBasicTypes.INTEGER)
 .addScalar("description", StandardBasicTypes.STRING);
 for (Fixing fixing: fixings) {
 fixing.loadColumnsKmRange(query);
 }
 }
-protected void loadFixingsColumnsQRanges(Session session) {
+protected void loadFixingsColumnsQRanges(
+Session     session,
+GaugeFinder gaugeFinder
+) {
 SQLQuery query = session.createSQLQuery(SQL_FIXING_COLUMN_Q_RANGES)
 .addScalar("q",        StandardBasicTypes.DOUBLE)
 .addScalar("start_km", StandardBasicTypes.DOUBLE)
 .addScalar("stop_km",  StandardBasicTypes.DOUBLE);
 for (Fixing fixing: fixings) {
-fixing.loadColumnsQRanges(query);
+fixing.loadColumnsQRanges(query, gaugeFinder);
 }
 }
 public boolean load(Session session) {
-if (!loadRiver(session)) {
+if (!loadRiver(session)
+||  !loadRiverExtent(session)) {
 return false;
 }
-if (!loadRiverExtent(session)) {
+GaugeFinder gaugeFinder = loadGauges(session);
-return false;
-}
+if (gaugeFinder == null
+|| !gaugeFinder.loadDischargeSectors(session, riverId)) {
-if (!loadGauges(session)) {
-return false;
-}
-if (!loadDischargeSectors(session)) {
 return false;
 }
 loadFixings(session);
 loadFixingsColumns(session);
 loadFixingsColumnsKmRange(session);
-loadFixingsColumnsQRanges(session);
+loadFixingsColumnsQRanges(session, gaugeFinder);
 return true;
 }
+private static final Range FULL_EXTENT =
+new Range(-Double.MAX_VALUE, Double.MAX_VALUE);
 public void generateOverview(Document document) {
+generateOverview(document, FULL_EXTENT);
+}
+public void generateOverview(Document document, Range range) {
 List<Fixing.Column> allColumns = new ArrayList<Fixing.Column>();
 for (Fixing fixing: fixings) {
-fixing.addAllColumns(allColumns);
+fixing.addAllColumns(allColumns, range);
 }
 Collections.sort(allColumns, Fixing.DATE_CMP);
 Element fixingsElement = document.createElement("fixings");
 Element esE = document.createElement("events");
 for (Fixing.Column column: allColumns) {
-double km = isKmUp ? column.start : column.end;
+// TODO: Apply additional filters here.
+List<SectorRange> sectors = column.getSectors();
-GaugeRange gauge = findGaugeByKm(km);
-if (gauge == null) {
-log.warn("Cannot find gauge for km " + km + ".");
-continue;
-}
-List<SectorRange> sectors = column.classify(gauge);
 if (!sectors.isEmpty()) {
 Element eE = document.createElement("event");
 eE.setAttribute("name",
 String.valueOf(column.getFixing().description));

Mercurial > dive4elements > river

comparison flys-artifacts/src/main/java/de/intevation/flys/artifacts/model/FixingsOverview.java @ 2562:ba35dfb7c09a