/**
   * The <code>RGB2HMMD (int ir, int ig, int ib)</code> class is responsible for converting RGB
   * values to HMMD values
   *
   * @param ir - RED component
   * @param ig - GREEN component
   * @param ib - BLUE component
   * @return int[] - HMMD value of the pixle
   * @throws Exception
   * @author [email protected]
   */
  private static int[] RGB2HMMD(int ir, int ig, int ib) throws Exception {
    int HMMD[] = new int[5];

    float max = (float) Math.max(Math.max(ir, ig), Math.max(ig, ib));
    float min = (float) Math.min(Math.min(ir, ig), Math.min(ig, ib));

    float diff = (max - min);
    float sum = (float) ((max + min) / 2.);

    float hue = 0;
    if (diff == 0) hue = 0;
    else if (ir == max && (ig - ib) > 0) hue = 60 * (ig - ib) / (max - min);
    else if (ir == max && (ig - ib) <= 0) hue = 60 * (ig - ib) / (max - min) + 360;
    else if (ig == max) hue = (float) (60 * (2. + (ib - ir) / (max - min)));
    else if (ib == max) hue = (float) (60 * (4. + (ir - ig) / (max - min)));

    diff /= 2;

    HMMD[0] = (int) (hue);
    HMMD[1] = (int) (max);
    HMMD[2] = (int) (min);
    HMMD[3] = (int) (diff);
    HMMD[4] = (int) (sum);

    return (HMMD);
  }
Beispiel #2
1
 @Test
 public void max3float() {
   assertEquals(0.3f, Math.max(0.1f, 0.2f, 0.3f), 0.0);
   assertEquals(0.31f, Math.max(0.31f, 0.2f, 0.3f), 0.0);
   assertEquals(0.5f, Math.max(0.1f, 0.5f, 0.3f), 0.0);
   assertEquals(0.5f, Math.max(-10.1f, 0.5f, -0.3f), 0.0);
 }
Beispiel #3
1
 @Test
 public void max4int() {
   assertEquals(5, Math.max(-10, 5, 3, 1));
   assertEquals(10, Math.max(10, 5, 3, 1));
   assertEquals(13, Math.max(-10, 5, 13, 1));
   assertEquals(15, Math.max(-10, 5, 3, 15));
 }
 @Override
 public Vector getMaximumPoint() {
   return new Vector(
       Math.max(pos1.getX(), pos2.getX()),
       Math.max(pos1.getY(), pos2.getY()),
       Math.max(pos1.getZ(), pos2.getZ()));
 }
  /**
   * Find all News entities with a specific property value.
   *
   * @param propertyName the name of the News property to query
   * @param value the property value to match
   * @param rowStartIdxAndCount Optional int varargs. rowStartIdxAndCount[0] specifies the the row
   *     index in the query result-set to begin collecting the results. rowStartIdxAndCount[1]
   *     specifies the the maximum number of results to return.
   * @return List<News> found by query
   */
  @SuppressWarnings("unchecked")
  public List<News> findByProperty(
      String propertyName, final Object value, final int... rowStartIdxAndCount) {
    LogUtil.log(
        "finding News instance with property: " + propertyName + ", value: " + value,
        Level.INFO,
        null);
    try {
      final String queryString =
          "select model from News model where model." + propertyName + "= :propertyValue";
      Query query = entityManager.createQuery(queryString);
      query.setParameter("propertyValue", value);
      if (rowStartIdxAndCount != null && rowStartIdxAndCount.length > 0) {
        int rowStartIdx = Math.max(0, rowStartIdxAndCount[0]);
        if (rowStartIdx > 0) {
          query.setFirstResult(rowStartIdx);
        }

        if (rowStartIdxAndCount.length > 1) {
          int rowCount = Math.max(0, rowStartIdxAndCount[1]);
          if (rowCount > 0) {
            query.setMaxResults(rowCount);
          }
        }
      }
      return query.getResultList();
    } catch (RuntimeException re) {
      LogUtil.log("find by property name failed", Level.SEVERE, re);
      throw re;
    }
  }
  @Override
  protected final void addMovementCells(
      SheetGraphics graphics,
      PdfPTable table,
      HealthLevelType level,
      int painTolerance,
      IGenericTraitCollection collection) {

    int woundPenalty = getPenalty(level, painTolerance);
    int dex = collection.getTrait(AttributeType.Dexterity).getCurrentValue();
    int str = collection.getTrait(AttributeType.Strength).getCurrentValue();
    int athletics = collection.getTrait(AbilityType.Athletics).getCurrentValue();

    // minimum move is 1, minimum dash is 2, minimum jump h/v, swim, & climb is unknown
    int move = Math.max(dex + woundPenalty + mobilityPenalty, 1);
    int dash = Math.max(dex + woundPenalty + mobilityPenalty + 6, 2);
    int verticalJump = str + athletics + woundPenalty + mobilityPenalty;
    int horizontalJump = verticalJump * 2;

    table.addCell(createMovementCell(graphics, move, 1));
    addSpaceCells(graphics, table, 1);
    table.addCell(createMovementCell(graphics, dash, 2));

    addSpaceCells(graphics, table, 1);
    table.addCell(createMovementCell(graphics, horizontalJump, 0));
    table.addCell(createMovementCell(graphics, verticalJump, 0));
  }
Beispiel #7
0
  /**
   * Formats a list of edits in unified diff format
   *
   * @param edits some differences which have been calculated between A and B
   * @param a the text A which was compared
   * @param b the text B which was compared
   * @throws IOException
   */
  public void format(final EditList edits, final RawText a, final RawText b) throws IOException {
    for (int curIdx = 0; curIdx < edits.size(); ) {
      Edit curEdit = edits.get(curIdx);
      final int endIdx = findCombinedEnd(edits, curIdx);
      final Edit endEdit = edits.get(endIdx);

      int aCur = Math.max(0, curEdit.getBeginA() - context);
      int bCur = Math.max(0, curEdit.getBeginB() - context);
      final int aEnd = Math.min(a.size(), endEdit.getEndA() + context);
      final int bEnd = Math.min(b.size(), endEdit.getEndB() + context);

      writeHunkHeader(aCur, aEnd, bCur, bEnd);

      while (aCur < aEnd || bCur < bEnd) {
        if (aCur < curEdit.getBeginA() || endIdx + 1 < curIdx) {
          writeContextLine(a, aCur);
          if (isEndOfLineMissing(a, aCur)) out.write(noNewLine);
          aCur++;
          bCur++;
        } else if (aCur < curEdit.getEndA()) {
          writeRemovedLine(a, aCur);
          if (isEndOfLineMissing(a, aCur)) out.write(noNewLine);
          aCur++;
        } else if (bCur < curEdit.getEndB()) {
          writeAddedLine(b, bCur);
          if (isEndOfLineMissing(b, bCur)) out.write(noNewLine);
          bCur++;
        }

        if (end(curEdit, aCur, bCur) && ++curIdx < edits.size()) curEdit = edits.get(curIdx);
      }
    }
  }
 /**
  * Convert all pixels to grayscale from RGB or RGBA. Do not call this method if the pixels are not
  * currently RGB or RGBA.
  *
  * @param normalize <code>true</code> to normalize the image after converting to grayscale, such
  *     that the darkest pixel in the image is all black and the lightest pixel in the image is all
  *     white.
  */
 public final void toGrayScale(boolean normalize) {
   if (npix == 0) {
     return;
   }
   if (!normalize) {
     for (int i = 0; i < npix; i++) {
       pixels[i] = rgbToGrayScale(pixels[i]);
     }
   } else {
     int pix;
     pixels[0] = pix = rgbToGrayScale(pixels[0]);
     int min = pix, max = pix;
     for (int i = 1; i < npix; i++) {
       pixels[i] = pix = rgbToGrayScale(pixels[i]);
       min = Math.min(min, pix);
       max = Math.max(max, pix);
     }
     int range = max - min;
     if (range < 1) {
       for (int i = 0; i < npix; i++) {
         pixels[i] = 255;
       }
     } else {
       for (int i = 0; i < npix; i++) {
         pixels[i] = Math.min(255, Math.max(0, ((pixels[i] - min) * 255) / range));
       }
     }
   }
 }
 /*12. 求二叉树中节点的最大距离
     具体分析(http://blog.csdn.net/lalor/article/details/7626678)
     即二叉树中相距最远的两个节点之间的距离。
     递归解法:
     (1)如果二叉树为空,返回0,同时记录左子树和右子树的深度,都为0
     (2)如果二叉树不为空,最大距离要么是左子树中的最大距离,要么是右子树中的最大距离,
     要么是左子树节点中到根节点的最大距离+右子树节点中到根节点的最大距离,
     同时记录左子树和右子树节点中到根节点的最大距离。
 */
 public static int getMaxDistance(TreeNode node, int maxLeft, int maxRight) {
   // maxLeft, 左子树中的节点距离左子树根节点的最远距离
   // maxRight, 右子树中的节点距离左子树根节点的最远距离
   if (node == null) {
     maxLeft = 0;
     maxRight = 0;
     return 0;
   }
   int maxLL = 0, maxLR = 0, maxRL = 0, maxRR = 0;
   int maxDistLeft, maxDistRight;
   if (node.left != null) {
     maxDistLeft = getMaxDistance(node.left, maxLL, maxLR);
     maxLeft = Math.max(maxLL, maxLR) + 1;
   } else {
     maxDistLeft = 0;
     maxLeft = 0;
   }
   if (node.right != null) {
     maxDistRight = getMaxDistance(node.right, maxRL, maxRR);
     maxRight = Math.max(maxRL, maxRR) + 1;
   } else {
     maxDistRight = 0;
     maxRight = 0;
   }
   int result = Math.max(Math.max(maxDistLeft, maxDistRight), maxLeft + maxRight + 1);
   return result;
 }
Beispiel #10
0
  @Override
  protected void render(boolean isTranslatable) {
    int yPos = 4;
    yPos += drawCenteredString(Lang.translate("Contents"), yPos);
    yPos += drawBlankLine() * 2;
    for (int i = 0; i < pages.size(); i++) {
      String pageTxt = Lang.translate("Page") + " " + pages.get(i);
      int x = PAGE_WIDTH - 4 - getStringWidth(pageTxt);

      int mY = drawTextLine(pageTxt, x, yPos);
      mY = Math.max(mY, drawTextBlock(contents.get(i), 4, yPos, x - 12));

      int s = 0;
      List<String> splitStr = manual.fonts.listFormattedStringToWidth(contents.get(i), x - 12);
      int BORDER = 2;
      for (String s1 : splitStr) {
        s = Math.max(s, BORDER + getStringWidth(s1));
      }

      int pw = manual.fonts.getStringWidth(".");
      if (s + pw < (x - BORDER)) {
        for (int nx = s; nx < (x - BORDER); nx += pw) {
          manual.fonts.drawString(".", nx, yPos, 0);
        }
      }
      yPos += mY;
    }
  }
Beispiel #11
0
  public int maxProfit(int[] prices) {
    if (prices == null || prices.length <= 1) {
      return 0;
    }
    int len = prices.length;
    int min = prices[0];
    int[] left_maxProfit = new int[len];
    // compute the left profit. Store each value at left_maxProfit
    for (int i = 1; i < len; i++) {
      left_maxProfit[i] = Math.max(left_maxProfit[i - 1], prices[i] - min);
      min = Math.min(min, prices[i]);
    }
    // compute the right profit.
    int max = prices[len - 1];
    int right_maxProfit = 0;
    int total_profit = left_maxProfit[len - 1];

    for (int i = len - 2; i >= 0; i--) {
      right_maxProfit = Math.max(right_maxProfit, max - prices[i]);
      max = Math.max(max, prices[i]);
      total_profit = Math.max(total_profit, left_maxProfit[i] + right_maxProfit);
    }

    return total_profit;
  }
Beispiel #12
0
  /**
   * Instantiates a new hud.
   *
   * @param u1 the u1
   * @param u2 the u2
   * @param stage the stage
   */
  public HUD(Unit u1, Unit u2, FightStage stage) {
    super(0, 0);
    this.unit = u1;
    sign = stage.isLeft(u1) ? -1 : 1;
    this.stage = stage;
    if (battleStats == null) battleStats = FEResources.getTexture("gui_battleStats");

    if (!CombatCalculator.shouldAttack(u1, u2, u1.getWeapon(), stage.getRange())) {
      hit = "  -";
      crit = "  -";
      dmg = "  -";
    } else {
      hit = String.format("%3d", Math.min(100, Math.max(CombatCalculator.hitRate(u1, u2), 0)));
      crit = String.format("%3d", Math.min(100, Math.max(u1.crit() - u2.dodge(), 0)));
      dmg =
          String.format(
              "%3d", Math.min(100, Math.max(CombatCalculator.calculatePreviewDamage(u1, u2), 0)));
    }

    renderDepth = FightStage.HUD_DEPTH;

    stage.addEntity(
        new ItemDisplay(
            FightStage.CENTRAL_AXIS + sign * 39 - 37,
            FightStage.FLOOR + 13,
            u1.getWeapon(),
            false));
  }
  private static ExecutorService startAlertClientService(
      SystemMain system, AtomicInteger jobCounter) {
    int configuredCount =
        Integer.valueOf(
            system.getConfiguration().getValue(SystemConfiguration.Property.CLIENT_THREADS));
    int configuredTimeout =
        Integer.valueOf(
            system
                .getConfiguration()
                .getValue(SystemConfiguration.Property.CLIENT_CONNECT_TIMEOUT));
    int threadPoolCount = Math.max(configuredCount, 2);
    int timeout = Math.max(10000, configuredTimeout);
    ExecutorService service =
        Executors.newFixedThreadPool(
            threadPoolCount,
            new ThreadFactory() {

              AtomicInteger id = new AtomicInteger(0);

              @Override
              public Thread newThread(Runnable r) {
                return new Thread(r, MessageFormat.format("alertclient-{0}", id.getAndIncrement()));
              }
            });
    system.getServiceFactory().getMonitorService().startRecordingCounters();
    for (int i = 0; i < threadPoolCount; i++) {
      service.submit(
          new Alerter(system.getServiceFactory().getAlertService(), timeout, jobCounter));
    }
    return service;
  }
Beispiel #14
0
 private static int parseByteSize(String size_str) {
   int idxOfKilo = Math.max(size_str.indexOf('k'), size_str.indexOf('K'));
   int idxOfMega = Math.max(size_str.indexOf('m'), size_str.indexOf('M'));
   if (idxOfKilo > 0) return Integer.parseInt(size_str.substring(0, idxOfKilo)) * 1024;
   else if (idxOfMega > 0) return Integer.parseInt(size_str.substring(0, idxOfMega)) * 1024 * 1024;
   else return Integer.parseInt(size_str);
 }
Beispiel #15
0
 @Override
 protected ClickableArea[] clickableAreasForPoints(
     List<Float> points, List<Double> values, float yAxisValue, int seriesIndex, int startIndex) {
   int seriesNr = mDataset.getSeriesCount();
   int length = points.size();
   ClickableArea[] ret = new ClickableArea[length / 2];
   float halfDiffX = getHalfDiffX(points, length, seriesNr);
   for (int i = 0; i < length; i += 2) {
     float x = points.get(i);
     float y = points.get(i + 1);
     if (mType == Type.STACKED || mType == Type.HEAPED) {
       ret[i / 2] =
           new ClickableArea(
               new RectF(
                   x - halfDiffX, Math.min(y, yAxisValue), x + halfDiffX, Math.max(y, yAxisValue)),
               values.get(i),
               values.get(i + 1));
     } else {
       float startX = x - seriesNr * halfDiffX + seriesIndex * 2 * halfDiffX;
       ret[i / 2] =
           new ClickableArea(
               new RectF(
                   startX,
                   Math.min(y, yAxisValue),
                   startX + 2 * halfDiffX,
                   Math.max(y, yAxisValue)),
               values.get(i),
               values.get(i + 1));
     }
   }
   return ret;
 }
 Point minimumSize(int wHint, int hHint, boolean flushCache) {
   Control[] children = _getChildren();
   int width = 0, height = 0;
   for (int i = 0; i < children.length; i++) {
     Control child = children[i];
     int index = 0;
     int count = 0;
     long /*int*/ list = OS.gtk_container_get_children(handle);
     if (list != 0) {
       count = OS.g_list_length(list);
       OS.g_list_free(list);
     }
     while (index < count) {
       if (items[index].control == child) break;
       index++;
     }
     if (index == count) {
       Rectangle rect = child.getBounds();
       width = Math.max(width, rect.x + rect.width);
       height = Math.max(height, rect.y + rect.height);
     } else {
       Point size = child.computeSize(wHint, hHint, flushCache);
       width = Math.max(width, size.x);
       height = Math.max(height, size.y);
     }
   }
   return new Point(width, height);
 }
Beispiel #17
0
  public long countTriplets(int minx, int maxx, int miny, int maxy, int minz, int maxz) {
    long ans = 0;
    int lim = 1 << 16;
    for (int x = minx; x <= maxx && x < lim; x++) {
      long miny2 = minz / x;
      if (x * miny2 < minz) miny2++;
      miny2 = Math.max(miny2, miny);

      long maxy2 = maxz / x;
      maxy2 = Math.min(maxy2, maxy);

      if (maxy2 >= miny2) ans += maxy2 - miny2 + 1;
    }
    for (int y = miny; y <= maxy && y < lim; y++) {
      long minx2 = minz / y;
      if (y * minx2 < minz) minx2++;
      minx2 = Math.max(minx2, minx);
      minx2 = Math.max(minx2, lim);

      long maxx2 = maxz / y;
      maxx2 = Math.min(maxx2, maxx);

      if (maxx2 >= minx2) ans += maxx2 - minx2 + 1;
    }
    return ans;
  }
  public int largestRectangleArea(int[] height) {

    int area = 0, border;
    Stack<Node> heightStack = new Stack<Node>();
    heightStack.push(new Node(-1, -1));
    Node temNode;
    for (int i = 0; i < height.length; i++) {
      if (heightStack.peek().height < height[i]) {
        heightStack.push(new Node(height[i], i));
      } else {
        temNode = heightStack.peek();
        border = temNode.index;
        while (heightStack.peek().height > height[i]) {
          temNode = heightStack.pop();
          area = Math.max((border - heightStack.peek().index) * temNode.height, area);
        }
        area = Math.max((i - heightStack.peek().index) * height[i], area);
        heightStack.push(new Node(height[i], i));
      }
    }
    border = heightStack.peek().index;
    while (!heightStack.empty()) {
      Node tem = heightStack.pop();
      if (heightStack.empty()) return area;
      area = Math.max(area, tem.height * (border - heightStack.peek().index));
    }
    return area;
  }
  private void preload(int from, int to) {
    int start;
    int end;
    if (from < to) {
      start = Math.max(lastEnd, from);
      end = to;
    } else {
      start = to;
      end = Math.min(lastStart, from);
    }
    end = Math.min(totalItemCount, end);
    start = Math.min(totalItemCount, Math.max(0, start));

    if (from < to) {
      // Increasing
      for (int i = start; i < end; i++) {
        preloadAdapterPosition(this.preloadModelProvider.getPreloadItems(i), i, true);
      }
    } else {
      // Decreasing
      for (int i = end - 1; i >= start; i--) {
        preloadAdapterPosition(this.preloadModelProvider.getPreloadItems(i), i, false);
      }
    }

    lastStart = start;
    lastEnd = end;
  }
 static String getBanDurationBreakdown(final Timestamp stamp) {
   if (stamp == null) return "Banned Forever";
   final long millis = stamp.getTime() - System.currentTimeMillis();
   if (millis < 0) return "Ban time left: 1 Minute";
   long seconds = Math.max(1, TimeUnit.MILLISECONDS.toSeconds(millis));
   final int minutesInSeconds = 60;
   final int hoursInSeconds = 60 * 60;
   final int daysInSeconds = 60 * 60 * 24;
   final long days = seconds / daysInSeconds;
   seconds -= days * daysInSeconds;
   final long hours = seconds / hoursInSeconds;
   seconds -= hours * hoursInSeconds;
   final long minutes = Math.max(1, seconds / minutesInSeconds);
   /*
   final long days = TimeUnit.MILLISECONDS.toDays(millis);
   millis -= TimeUnit.DAYS.toMillis(days);
   final long hours = TimeUnit.MILLISECONDS.toHours(millis);
   millis -= TimeUnit.HOURS.toMillis(hours);
   final long minutes = TimeUnit.MILLISECONDS.toMinutes(millis) + 1;*/
   final StringBuilder sb = new StringBuilder(64);
   sb.append("Ban time left: ");
   if (days > 0) {
     sb.append(days);
     sb.append(" Days ");
   }
   if (hours > 0) {
     sb.append(hours);
     sb.append(" Hours ");
   }
   if (minutes > 0) {
     sb.append(minutes);
     sb.append(" Minutes ");
   }
   return (sb.toString());
 }
Beispiel #21
0
 protected static void parseArgs(final String[] args) {
   int i = 0;
   while (i < args.length) {
     final String loopOptionKey = args[i];
     switch (loopOptionKey) {
       case "-n":
         i += 1;
         SIZE = Math.max(1, Math.min(Integer.parseInt(args[i]), MAX_SOLUTIONS));
         break;
       case "-t":
         i += 1;
         THRESHOLD = Math.max(1, Math.min(Integer.parseInt(args[i]), MAX_SOLUTIONS));
         break;
       case "-w":
         i += 1;
         NUM_WORKERS = Integer.parseInt(args[i]);
         break;
       case "-s":
         i += 1;
         SOLUTIONS_LIMIT = Integer.parseInt(args[i]);
         break;
       case "-p":
         i += 1;
         final int priority = Integer.parseInt(args[i]);
         final int maxPriority = MessagePriority.values().length - 1;
         PRIORITIES = Math.max(1, Math.min(priority, maxPriority));
         break;
       case "-debug":
       case "-verbose":
         debug = true;
         break;
     }
     i += 1;
   }
 }
 private RECT getCharacterBounds(Set<Integer> characters, Set<BoundedTag> added) {
   RECT ret = new RECT(Integer.MAX_VALUE, Integer.MIN_VALUE, Integer.MAX_VALUE, Integer.MIN_VALUE);
   boolean foundSomething = false;
   for (int c : characters) {
     Tag t = swf.getCharacter(c);
     RECT r = null;
     if (t instanceof BoundedTag) {
       BoundedTag bt = (BoundedTag) t;
       if (!added.contains(bt)) {
         added.add(bt);
         r = bt.getRect(added);
         added.remove(bt);
       }
     }
     if (r != null) {
       foundSomething = true;
       ret.Xmin = Math.min(r.Xmin, ret.Xmin);
       ret.Ymin = Math.min(r.Ymin, ret.Ymin);
       ret.Xmax = Math.max(r.Xmax, ret.Xmax);
       ret.Ymax = Math.max(r.Ymax, ret.Ymax);
     }
   }
   if (!foundSomething) {
     return new RECT();
   }
   return ret;
 }
  @Override
  public void convert(final RealComposite<T> input, final ARGBDoubleType output) {
    output.setZero();
    for (int i = 0; i < argbs.length; ++i) {
      final double t = input.get(i).getRealDouble();
      final ARGBDoubleType c = argbs[i];
      final double a = c.getA();
      final double r = output.getR() + a * c.getR() * t;
      final double g = output.getG() + a * c.getG() * t;
      final double b = output.getB() + a * c.getB() * t;

      output.setR(r);
      output.setG(g);
      output.setB(b);
    }

    final double r = output.getR();
    final double g = output.getG();
    final double b = output.getB();

    //		final double a = ( r + g + b ) / 3.0;
    final double a = Math.max(0, Math.min(1.0, Math.max(r, Math.max(g, b))));
    //		final double a = Math.max( r, Math.max( g, b ) );

    output.set(a, r, g, b);
  }
Beispiel #24
0
 public static int getMax(int c0, int c1) {
   return getColor(
       1,
       Math.max(getRed(c0), getRed(c1)),
       Math.max(getGreen(c0), getGreen(c1)),
       Math.max(getBlue(c0), getBlue(c1)));
 }
  /**
   * Find all News entities.
   *
   * @param rowStartIdxAndCount Optional int varargs. rowStartIdxAndCount[0] specifies the the row
   *     index in the query result-set to begin collecting the results. rowStartIdxAndCount[1]
   *     specifies the the maximum count of results to return.
   * @return List<News> all News entities
   */
  @SuppressWarnings("unchecked")
  public List<News> findAll(final int... rowStartIdxAndCount) {
    LogUtil.log("finding all News instances", Level.INFO, null);
    try {
      final String queryString = "select model from News model";
      Query query = entityManager.createQuery(queryString);
      if (rowStartIdxAndCount != null && rowStartIdxAndCount.length > 0) {
        int rowStartIdx = Math.max(0, rowStartIdxAndCount[0]);
        if (rowStartIdx > 0) {
          query.setFirstResult(rowStartIdx);
        }

        if (rowStartIdxAndCount.length > 1) {
          int rowCount = Math.max(0, rowStartIdxAndCount[1]);
          if (rowCount > 0) {
            query.setMaxResults(rowCount);
          }
        }
      }
      return query.getResultList();
    } catch (RuntimeException re) {
      LogUtil.log("find all failed", Level.SEVERE, re);
      throw re;
    }
  }
  private BufferedImage aplicaFiltroMatrizConvolucion(
      double[][] filter, double factor, double bias, BufferedImage img) {

    imgTmp = new BufferedImage(img.getWidth(), img.getHeight(), img.getType());
    for (int x = 0; x < img.getWidth(); x++) {
      for (int y = 0; y < img.getHeight(); y++) {
        int r = 0, g = 0, b = 0;

        for (int filterX = 0; filterX < filter.length; filterX++)
          for (int filterY = 0; filterY < filter.length; filterY++) {
            int imageX = (x - filter.length / 2 + filterX + img.getWidth()) % img.getWidth();
            int imageY = (y - filter.length / 2 + filterY + img.getHeight()) % img.getHeight();
            Color c = new Color(img.getRGB(imageX, imageY));
            r += c.getRed() * filter[filterX][filterY];
            g += c.getGreen() * filter[filterX][filterY];
            b += c.getBlue() * filter[filterX][filterY];
          }
        imgTmp.setRGB(
            x,
            y,
            new Color(
                    Math.min(Math.max((int) (factor * r + bias), 0), 255),
                    Math.min(Math.max((int) (factor * g + bias), 0), 255),
                    Math.min(Math.max((int) (factor * b + bias), 0), 255))
                .getRGB());
      }
    }
    return imgTmp;
  }
Beispiel #27
0
 @Test
 public void max4float() {
   assertEquals(36.9f, Math.max(10.1f, 5.45f, -3.12f, 36.9f), 0.0);
   assertEquals(10.1f, Math.max(10.1f, 5.45f, -3.12f, 6.9f), 0.0);
   assertEquals(-3.12f, Math.max(-10.1f, -5.45f, -3.12f, -36.9f), 0.0);
   assertEquals(25.45f, Math.max(10.1f, 25.45f, -3.12f, 16.9f), 0.0);
 }
 public void chartProgress(ChartProgressEvent chartprogressevent) {
   if (chartprogressevent.getType() != 2) return;
   if (chartPanel != null) {
     JFreeChart jfreechart = chartPanel.getChart();
     if (jfreechart != null) {
       XYPlot xyplot = (XYPlot) jfreechart.getPlot();
       XYDataset xydataset = xyplot.getDataset();
       @SuppressWarnings("rawtypes")
       Comparable comparable = xydataset.getSeriesKey(0);
       double d = xyplot.getDomainCrosshairValue();
       model.setValueAt(comparable, 0, 0);
       long l = (long) d;
       model.setValueAt(new Long(l), 0, 1);
       int i = series.getIndex(new Minute(new Date(l)));
       if (i >= 0) {
         TimeSeriesDataItem timeseriesdataitem =
             series.getDataItem(Math.min(199, Math.max(0, i)));
         TimeSeriesDataItem timeseriesdataitem1 = series.getDataItem(Math.max(0, i - 1));
         TimeSeriesDataItem timeseriesdataitem2 = series.getDataItem(Math.min(199, i + 1));
         long l1 = timeseriesdataitem.getPeriod().getMiddleMillisecond();
         double d1 = timeseriesdataitem.getValue().doubleValue();
         long l2 = timeseriesdataitem1.getPeriod().getMiddleMillisecond();
         double d2 = timeseriesdataitem1.getValue().doubleValue();
         long l3 = timeseriesdataitem2.getPeriod().getMiddleMillisecond();
         double d3 = timeseriesdataitem2.getValue().doubleValue();
         model.setValueAt(new Long(l1), 0, 1);
         model.setValueAt(new Double(d1), 0, 2);
         model.setValueAt(new Long(l2), 0, 3);
         model.setValueAt(new Double(d2), 0, 4);
         model.setValueAt(new Long(l3), 0, 5);
         model.setValueAt(new Double(d3), 0, 6);
       }
     }
   }
 }
  private void setupContentDimensions(int count) {
    ArrayList<View> list = getItemsInReadingOrder();

    int countX = mContent.getCountX();
    int countY = mContent.getCountY();
    boolean done = false;

    while (!done) {
      int oldCountX = countX;
      int oldCountY = countY;
      if (countX * countY < count) {
        // Current grid is too small, expand it
        if ((countX <= countY || countY == mMaxCountY) && countX < mMaxCountX) {
          countX++;
        } else if (countY < mMaxCountY) {
          countY++;
        }
        if (countY == 0) countY++;
      } else if ((countY - 1) * countX >= count && countY >= countX) {
        countY = Math.max(0, countY - 1);
      } else if ((countX - 1) * countY >= count) {
        countX = Math.max(0, countX - 1);
      }
      done = countX == oldCountX && countY == oldCountY;
    }
    mContent.setGridSize(countX, countY);
    arrangeChildren(list);
  }
Beispiel #30
0
 public void fitToSize(int width, int height) {
   width = Math.max(width, 300);
   height = Math.max(height, 100);
   // this.setWidth(width + "px");
   // this.setHeight(height + "px");
   // setGridWidth(width - 10, height - 40);
 }