public Numerical1DDataDomainValues(TablePerspective data, EDimension main) {
    super(data, main);
    Perspective p = main.select(data.getDimensionPerspective(), data.getRecordPerspective());
    this.groups = Numerical1DMixin.extractGroups(p, this);
    this.isInteger = DataSupportDefinitions.dataClass(EDataClass.NATURAL_NUMBER).apply(data);

    Object desc = getDescription();
    Float min = null, max = null;
    if (desc instanceof NumericalProperties) {
      min = ((NumericalProperties) desc).getMin();
      max = ((NumericalProperties) desc).getMax();
    }
    if (min == null || min.isNaN() || max == null || max.isNaN()) {
      DoubleStatistics stats = createStats(this, groups);
      if (min == null || min.isNaN()) min = (float) stats.getMin();
      if (max == null || max.isNaN()) max = (float) stats.getMax();
    }
    this.mixin = new Numerical1DMixin(this, groups, min.floatValue(), max.floatValue());
  }
Ejemplo n.º 2
0
  /**
   * @param buffer
   * @param tile
   * @param pool
   * @return
   */
  private Tile createTile(
      FloatBuffer buffer,
      Rectangle tile,
      GL gl,
      Deque<Texture> pool,
      TablePerspective tablePerspective) {
    final VirtualArray recordVA = tablePerspective.getRecordPerspective().getVirtualArray();
    final VirtualArray dimVA = tablePerspective.getDimensionPerspective().getVirtualArray();
    final ATableBasedDataDomain dataDomain = tablePerspective.getDataDomain();
    final int ilast = tile.y + tile.height;
    final int jlast = tile.x + tile.width;

    // fill buffer
    buffer.rewind();
    for (int i = tile.y; i < ilast; ++i) {
      int recordID = recordVA.get(i);
      for (int j = tile.x; j < jlast; ++j) {
        int dimensionID = dimVA.get(j);
        Color color = blockColorer.apply(recordID, dimensionID, dataDomain, false);
        buffer.put(color.getRGBA());
      }
    }

    // load to texture
    buffer.rewind();
    Texture texture;
    if (!pool.isEmpty()) texture = pool.poll();
    else texture = TextureIO.newTexture(GL.GL_TEXTURE_2D);

    TextureData texData = asTextureData(buffer, tile.width, tile.height);
    texture.updateImage(gl, texData);
    gl.glFlush();
    texData.destroy();

    return new Tile(tile, texture);
  }
Ejemplo n.º 3
0
 /**
  * @param context
  * @return
  */
 private boolean hasTablePerspective(GLElementFactoryContext context) {
   TablePerspective d = context.getData();
   if (d == null) return false;
   if (!DataSupportDefinitions.homogenousColumns.apply(d)) return false;
   return d.getNrDimensions() == 1 || d.getNrRecords() == 1;
 }
Ejemplo n.º 4
0
  /** @param context */
  public void create(IGLElementContext context, TablePerspective tablePerspective) {
    final GL gl = GLContext.getCurrentGL();

    final int numberOfRecords = tablePerspective.getRecordPerspective().getVirtualArray().size();
    final int numberOfDimensions =
        tablePerspective.getDimensionPerspective().getVirtualArray().size();
    dimension = new Dimension(numberOfDimensions, numberOfRecords);

    if (numberOfDimensions <= 0 || numberOfRecords <= 0) {
      takeDown();
      return;
    }

    final int maxSize = resolveMaxSize(gl);

    boolean needXTiling = numberOfDimensions > maxSize;
    boolean needYTiling = numberOfRecords > maxSize;

    // pool of old texture which we might wanna reuse
    final Deque<Texture> pool = new LinkedList<>();
    for (Tile tile : tiles) {
      pool.add(tile.texture);
    }
    tiles.clear();

    if (!needXTiling && !needYTiling) {
      // single tile
      FloatBuffer buffer =
          FloatBuffer.allocate(numberOfDimensions * numberOfRecords * 4); // w*h*rgba
      Rectangle tile = new Rectangle(0, 0, numberOfDimensions, numberOfRecords);
      tiles.add(createTile(buffer, tile, gl, pool, tablePerspective));
    } else if (needXTiling && !needYTiling) {
      // tile in x direction only
      FloatBuffer buffer = FloatBuffer.allocate(maxSize * numberOfRecords * 4); // w*h*rgba
      // fill full
      int lastTile = numberOfDimensions - maxSize;
      for (int i = 0; i < lastTile; i += maxSize) {
        Rectangle tile = new Rectangle(i, 0, maxSize, numberOfRecords);
        tiles.add(createTile(buffer, tile, gl, pool, tablePerspective));
      }
      { // create rest
        int remaining = numberOfDimensions % maxSize;
        Rectangle tile =
            new Rectangle(numberOfDimensions - remaining, 0, remaining, numberOfRecords);
        tiles.add(createTile(buffer, tile, gl, pool, tablePerspective));
      }
    } else if (!needXTiling && needYTiling) {
      // tile in y direction only
      FloatBuffer buffer = FloatBuffer.allocate(numberOfDimensions * maxSize * 4); // w*h*rgba
      // fill full
      int lastTile = numberOfRecords - maxSize;
      for (int i = 0; i < lastTile; i += maxSize) {
        Rectangle tile = new Rectangle(0, i, numberOfDimensions, maxSize);
        tiles.add(createTile(buffer, tile, gl, pool, tablePerspective));
      }
      { // create rest
        int remaining = numberOfRecords % maxSize;
        Rectangle tile =
            new Rectangle(0, numberOfRecords - remaining, numberOfDimensions, remaining);
        tiles.add(createTile(buffer, tile, gl, pool, tablePerspective));
      }
    } else {
      // tile in both directions
      // tile in y direction only
      FloatBuffer buffer = FloatBuffer.allocate(maxSize * maxSize * 4); // w*h*rgba
      // fill full
      int lastTileR = numberOfRecords - maxSize;
      int lastTileD = numberOfDimensions - maxSize;
      for (int i = 0; i < lastTileR; i += maxSize) {
        for (int j = 0; j < lastTileD; j += maxSize) {
          Rectangle tile = new Rectangle(j, i, maxSize, maxSize);
          tiles.add(createTile(buffer, tile, gl, pool, tablePerspective));
        }
        { // create rest
          int remaining = numberOfDimensions % maxSize;
          Rectangle tile = new Rectangle(numberOfDimensions - remaining, i, remaining, maxSize);
          tiles.add(createTile(buffer, tile, gl, pool, tablePerspective));
        }
      }
      { // last line
        int iremaining = numberOfRecords % maxSize;
        int i = numberOfRecords - iremaining;
        for (int j = 0; j < lastTileD; j += maxSize) {
          Rectangle tile = new Rectangle(j, i, maxSize, iremaining);
          tiles.add(createTile(buffer, tile, gl, pool, tablePerspective));
        }
        { // create rest
          int remaining = numberOfDimensions % maxSize;
          Rectangle tile = new Rectangle(numberOfDimensions - remaining, i, remaining, iremaining);
          tiles.add(createTile(buffer, tile, gl, pool, tablePerspective));
        }
      }
    }

    // free remaining elements in pool
    for (Texture tex : pool) tex.destroy(gl);
    pool.clear();
  }