us.ihmc.javaFXToolkit.shapes.JavaFXMultiColorMeshBuilder.<init> java code examples

Add the Codota plugin to your IDE and get smart completions

private void myMethod () {
 Charset c =String charsetName;Charset.forName(charsetName)
Charset.defaultCharset()
ContentType contentType;contentType.getCharset()
Smart code suggestions by Tabnine
}

public JavaFXPlanarRegionsViewer()
{
 TextureColorPalette2D colorPalette = new TextureColorPalette2D();
 colorPalette.setHueBrightnessBased(0.9);
 meshBuilder = new JavaFXMultiColorMeshBuilder(colorPalette);
 renderer = new AnimationTimer()
 {
   @Override
   public void handle(long now)
   {
    render();
   }
 };
}

public LidarScanLogViewer()
{
 JavaFXCoordinateSystem lidarFrame = new JavaFXCoordinateSystem(0.1);
 lidarFrame.getTransforms().add(lidarPose);
 root.getChildren().addAll(lidarFrame, scans);
 TextureColorPalette1D scanColorPalette = new TextureColorPalette1D();
 scanColorPalette.setHueBased(1.0, 1.0);
 scanMeshBuilder = new JavaFXMultiColorMeshBuilder(scanColorPalette);
}

public LidarScanLogViewer()
{
 JavaFXCoordinateSystem lidarFrame = new JavaFXCoordinateSystem(0.1);
 lidarFrame.getTransforms().add(lidarPose);
 root.getChildren().addAll(lidarFrame, scans);
 TextureColorPalette1D scanColorPalette = new TextureColorPalette1D();
 scanColorPalette.setHueBased(1.0, 1.0);
 scanMeshBuilder = new JavaFXMultiColorMeshBuilder(scanColorPalette);
}

public PlanarRegionsMeshBuilder(REAUIMessager uiMessager)
{
 this.uiMessager = uiMessager;
 enable = uiMessager.createInput(REAModuleAPI.OcTreeEnable, false);
 clear = uiMessager.createInput(REAModuleAPI.PlanarRegionsPolygonizerClear, false);
 clearOcTree = uiMessager.createInput(REAModuleAPI.OcTreeClear, false);
 planarRegionsListMessage = uiMessager.createInput(REAModuleAPI.PlanarRegionsState);
 TextureColorPalette2D colorPalette = new TextureColorPalette2D();
 colorPalette.setHueBrightnessBased(0.9);
 meshBuilder = new JavaFXMultiColorMeshBuilder(colorPalette);
}

private Node createConvexPolygonGraphics(PlanarRegion data)
{
 List<ConvexPolygon2D> convexPolygons = new ArrayList<>();
 for (int i = 0; i < data.getNumberOfConvexPolygons(); i++)
   convexPolygons.add(data.getConvexPolygon(i));
 JavaFXMultiColorMeshBuilder meshBuilder = new JavaFXMultiColorMeshBuilder(new TextureColorAdaptivePalette(64));
 int regionId = data.getRegionId();
 RigidBodyTransform rigidBodyTransform = new RigidBodyTransform();
 data.getTransformToWorld(rigidBodyTransform);
 Color regionColor = OcTreeMeshBuilder.getRegionColor(regionId);
 for (int i = 0; i < convexPolygons.size(); i++)
 {
   ConvexPolygon2D convexPolygon = convexPolygons.get(i);
   Color color = Color.hsb(regionColor.getHue(), 0.9, 0.5 + 0.5 * ((double) i / (double) convexPolygons.size()));
   meshBuilder.addPolygon(rigidBodyTransform, convexPolygon, color);
 }
 MeshView meshView = new MeshView(meshBuilder.generateMesh());
 meshView.setMaterial(meshBuilder.generateMaterial());
 return meshView;
}

private Node createConcaveHullGraphics(PlanarRegion data)
{
 int regionId = data.getRegionId();
 JavaFXMultiColorMeshBuilder meshBuilder = new JavaFXMultiColorMeshBuilder(new TextureColorAdaptivePalette(16));
 RigidBodyTransform transform = new RigidBodyTransform();
 data.getTransformToWorld(transform);
 Point2D[] concaveHullVerticesLocal = data.getConcaveHull();
 Color regionColor = OcTreeMeshBuilder.getRegionColor(regionId);
 List<Point3D> concaveHullVertices = Arrays.stream(concaveHullVerticesLocal).map(Point3D::new).map(p -> {
   transform.transform(p);
   return p;
 }).collect(Collectors.toList());
 for (int vertexIndex = 0; vertexIndex < concaveHullVertices.size(); vertexIndex++)
 {
   Point3D vertex = concaveHullVertices.get(vertexIndex);
   Point3D nextVertex = ListWrappingIndexTools.getNext(vertexIndex, concaveHullVertices);
   Color lineColor = Color.hsb(regionColor.getHue(), regionColor.getSaturation(), regionColor.getBrightness());
   meshBuilder.addLine(vertex, nextVertex, 0.0015, lineColor);
 }
 MeshView meshView = new MeshView(meshBuilder.generateMesh());
 meshView.setMaterial(meshBuilder.generateMaterial());
 meshView.setMouseTransparent(true);
 return meshView;
}

private Node createBorderTrianglesGraphics(PlanarRegionSegmentationRawData rawData,
                     ConcaveHullFactoryResult concaveHullFactoryResult)
{
 JavaFXMultiColorMeshBuilder meshBuilder = new JavaFXMultiColorMeshBuilder(new TextureColorAdaptivePalette(512));
 Point3D planeOrigin = rawData.getOrigin();
 Vector3D planeNormal = rawData.getNormal();
 for (ConcaveHullVariables intermediateVariables : concaveHullFactoryResult.getIntermediateVariables())
 {
   Set<QuadEdgeTriangle> borderTriangles = intermediateVariables.getBorderTriangles();
   for (QuadEdgeTriangle borderTriangle : borderTriangles)
   {
    List<Point2D> triangleVerticesLocal = Arrays.stream(borderTriangle.getVertices()).map(v -> new Point2D(v.getX(), v.getY()))
       .collect(Collectors.toList());
    List<Point3D> triangleVerticesWorld = PolygonizerTools.toPointsInWorld(triangleVerticesLocal, planeOrigin, planeNormal);
    double hue = 360.0 * random.nextDouble();
    double saturation = 0.8 * random.nextDouble() + 0.1;
    double brightness = 0.9;
    meshBuilder.addPolyon(triangleVerticesWorld, Color.hsb(hue, saturation, brightness));
   }
 }
 MeshView trianglesMeshView = new MeshView(meshBuilder.generateMesh());
 trianglesMeshView.setMaterial(meshBuilder.generateMaterial());
 return trianglesMeshView;
}

private Node createDelaunayTriangulationGraphics(PlanarRegionSegmentationRawData rawData,
                        ConcaveHullFactoryResult concaveHullFactoryResult)
{
 JavaFXMultiColorMeshBuilder meshBuilder = new JavaFXMultiColorMeshBuilder(new TextureColorAdaptivePalette(512));
 Point3D planeOrigin = rawData.getOrigin();
 Vector3D planeNormal = rawData.getNormal();
 List<QuadEdgeTriangle> allTriangles = concaveHullFactoryResult.getAllTriangles();
 for (QuadEdgeTriangle triangle : allTriangles)
 {
   List<Point2D> triangleVerticesLocal = Arrays.stream(triangle.getVertices()).map(v -> new Point2D(v.getX(), v.getY())).collect(Collectors.toList());
   triangleVerticesLocal.forEach(vertex -> {
    vertex.setX(vertex.getX() * scaleX);
    vertex.setY(vertex.getY() * scaleY);
   });
   List<Point3D> triangleVerticesWorld = PolygonizerTools.toPointsInWorld(triangleVerticesLocal, planeOrigin, planeNormal);
   double hue = 360.0 * random.nextDouble();
   double saturation = 0.8 * random.nextDouble() + 0.1;
   double brightness = 0.9;
   meshBuilder.addPolyon(triangleVerticesWorld, Color.hsb(hue, saturation, brightness));
 }
 MeshView trianglesMeshView = new MeshView(meshBuilder.generateMesh());
 trianglesMeshView.setMaterial(meshBuilder.generateMaterial());
 return trianglesMeshView;
}

private Node createConvexDecompositionGraphics(PlanarRegionSegmentationRawData rawData,
                       ConcaveHullFactoryResult concaveHullFactoryResult)
{
 ConcaveHullCollection concaveHullCollection = concaveHullFactoryResult.getConcaveHullCollection();
 double depthThreshold = polygonizerParameters.getDepthThreshold();
 List<ConvexPolygon2D> convexPolygons = new ArrayList<>();
 ConcaveHullDecomposition.recursiveApproximateDecomposition(concaveHullCollection, depthThreshold, convexPolygons);
 JavaFXMultiColorMeshBuilder meshBuilder = new JavaFXMultiColorMeshBuilder(new TextureColorAdaptivePalette(64));
 int regionId = rawData.getRegionId();
 RigidBodyTransform rigidBodyTransform = rawData.getTransformFromLocalToWorld();
 Color regionColor = OcTreeMeshBuilder.getRegionColor(regionId);
 for (int i = 0; i < convexPolygons.size(); i++)
 {
   ConvexPolygon2D convexPolygon = convexPolygons.get(i);
   Color color = Color.hsb(regionColor.getHue(), 0.9, 0.5 + 0.5 * ((double) i / (double) convexPolygons.size()));
   meshBuilder.addPolygon(rigidBodyTransform, convexPolygon, color);
 }
 MeshView meshView = new MeshView(meshBuilder.generateMesh());
 meshView.setMaterial(meshBuilder.generateMaterial());
 return meshView;
}

public NodeCheckerRenderer(Messager messager)
{
 nodeCheckerEnabled = messager.createInput(EnableNodeChecking, false);
 planarRegionsReference = messager.createInput(PlanarRegionDataTopic);
 footPositionReference = messager.createInput(NodeCheckingPosition);
 footOrientationReference = messager.createInput(NodeCheckingOrientation, new Quaternion());
 initialSupportSideReference = messager.createInput(InitialSupportSideTopic, RobotSide.LEFT);
 TextureColorPalette2D colorPalette = new TextureColorPalette2D();
 colorPalette.setHueBrightnessBased(0.9);
 meshBuilder = new JavaFXMultiColorMeshBuilder(colorPalette);
}

public ArrowGraphic(double radius, double length, Color color)
{
  TextureColorPalette1D colorPalette = new TextureColorPalette1D();
  colorPalette.setHueBased(1.0, 1.0);
  JavaFXMultiColorMeshBuilder meshBuilder = new JavaFXMultiColorMeshBuilder(colorPalette);
  double coneHeight = 0.10 * length;
  double coneRadius = 1.5 * radius;
  meshBuilder.addCylinder(length, radius, new Point3D(), new AxisAngle(0.0, 1.0, 0.0, Math.PI / 2.0), color);
  meshBuilder.addCone(coneHeight, coneRadius, new Point3D(length, 0.0, 0.0), new AxisAngle(0.0, 1.0, 0.0, Math.PI / 2.0), color);
  this.arrow = new MeshView(meshBuilder.generateMesh());
  arrow.setMaterial(meshBuilder.generateMaterial());
  getChildren().add(arrow);
}

private void processOccupancyMapMessage(FootstepPlannerOccupancyMapMessage message)
{
 palette.clearPalette();
 JavaFXMultiColorMeshBuilder meshBuilder = new JavaFXMultiColorMeshBuilder(palette);
 Object<FootstepPlannerCellMessage> occupiedCells = message.getOccupiedCells();
 for (int i = 0; i < occupiedCells.size(); i++)
 {
   FootstepPlannerCellMessage cell = occupiedCells.get(i);
   double x = cell.getXIndex() * FootstepNode.gridSizeXY;
   double y = cell.getYIndex() * FootstepNode.gridSizeXY;
   double z = getHeightAtPoint(x, y) + nodeOffsetZ;
   RigidBodyTransform transform = new RigidBodyTransform();
   transform.setTranslation(x, y, z);
   if (cell.getNodeIsValid())
    meshBuilder.addPolygon(transform, cellPolygon, validCellColor);
   else
    meshBuilder.addPolygon(transform, cellPolygon, rejectedCellColor);
 }
 footstepGraphToRender.set(new Pair<>(meshBuilder.generateMesh(), meshBuilder.generateMaterial()));
}

JavaFXMultiColorMeshBuilder meshBuilder = new JavaFXMultiColorMeshBuilder(new TextureColorPalette2D());

public OcTreeMeshBuilder(REAUIMessager uiMessager)
{
 this.uiMessager = uiMessager;
 enable = uiMessager.createInput(REAModuleAPI.OcTreeEnable, false);
 clear = uiMessager.createInput(REAModuleAPI.OcTreeClear, false);
 treeDepthForDisplay = uiMessager.createPropertyInput(REAModuleAPI.UIOcTreeDepth, Integer.MAX_VALUE);
 treeDepthForDisplay.addListener(this::setProcessChange);
 coloringType = uiMessager.createPropertyInput(REAModuleAPI.UIOcTreeColoringMode, ColoringType.DEFAULT);
 coloringType.addListener(this::setProcessChange);
 displayType = uiMessager.createPropertyInput(REAModuleAPI.UIOcTreeDisplayType, DisplayType.PLANE);
 displayType.addListener(this::setProcessChange);
 hidePlanarRegionNodes = uiMessager.createPropertyInput(REAModuleAPI.UIPlanarRegionHideNodes, false);
 hidePlanarRegionNodes.addListener(this::setProcessChange);
 ocTreeState = uiMessager.createInput(REAModuleAPI.OcTreeState);
 planarRegionSegmentationState = uiMessager.createInput(REAModuleAPI.PlanarRegionsSegmentationState);
 normalBasedColorPalette1D.setHueBased(0.9, 0.8);
 meshBuilder = new JavaFXMultiColorMeshBuilder(normalBasedColorPalette1D);
}

private Node createIntersectionsGraphics(PlanarRegionSegmentationRawData rawData)
{
 JavaFXMultiColorMeshBuilder meshBuilder = new JavaFXMultiColorMeshBuilder(new TextureColorAdaptivePalette(32));
 List<LineSegment2D> intersections2d = rawData.getIntersections();
 Point3D planeOrigin = rawData.getOrigin();
 Vector3D planeNormal = rawData.getNormal();
 List<LineSegment3D> intersections = PolygonizerTools.toLineSegmentsInWorld(intersections2d, planeOrigin, planeNormal);
 for (LineSegment3D intersection : intersections)
 {
   meshBuilder.addLine(intersection.getFirstEndpoint(), intersection.getSecondEndpoint(), 0.0025, Color.RED);
 }
 MeshView meshView = new MeshView(meshBuilder.generateMesh());
 meshView.setMaterial(meshBuilder.generateMaterial());
 meshView.visibleProperty().bind(showIntersections);
 return meshView;
}

@SuppressWarnings("unchecked")
private static Node createPrimaryEdgesGraphics(QuadEdgeSubdivision quadEdgeSubdivision, PlanarRegionSegmentationRawData rawData)
{
 List<QuadEdge> primaryEdges = (List<QuadEdge>) quadEdgeSubdivision.getPrimaryEdges(false);
 int regionId = rawData.getRegionId();
 JavaFXMultiColorMeshBuilder meshBuilder = new JavaFXMultiColorMeshBuilder(new TextureColorAdaptivePalette(16));
 Point3D planeOrigin = rawData.getOrigin();
 Quaternion planeOrientation = rawData.getOrientation();
 Color regionColor = OcTreeMeshBuilder.getRegionColor(regionId);
 for (QuadEdge edge : primaryEdges)
 {
   Point3D dest = PolygonizerTools.toPointInWorld(edge.dest().getX(), edge.dest().getY(), planeOrigin, planeOrientation);
   Point3D orig = PolygonizerTools.toPointInWorld(edge.orig().getX(), edge.orig().getY(), planeOrigin, planeOrientation);
   meshBuilder.addLine(dest, orig, 0.0015, regionColor);
 }
 MeshView meshView = new MeshView(meshBuilder.generateMesh());
 meshView.setMaterial(meshBuilder.generateMaterial());
 meshView.setMouseTransparent(true);
 return meshView;
}

@SuppressWarnings("unchecked")
private static Node createEdgesGraphics(QuadEdgeSubdivision quadEdgeSubdivision, PlanarRegionSegmentationRawData rawData)
{
 List<QuadEdge> edges = (List<QuadEdge>) quadEdgeSubdivision.getEdges();
 int regionId = rawData.getRegionId();
 JavaFXMultiColorMeshBuilder meshBuilder = new JavaFXMultiColorMeshBuilder(new TextureColorAdaptivePalette(16));
 Point3D planeOrigin = rawData.getOrigin();
 Quaternion planeOrientation = rawData.getOrientation();
 Color regionColor = OcTreeMeshBuilder.getRegionColor(regionId);
 for (QuadEdge edge : edges)
 {
   Point3D dest = PolygonizerTools.toPointInWorld(edge.dest().getX(), edge.dest().getY(), planeOrigin, planeOrientation);
   Point3D orig = PolygonizerTools.toPointInWorld(edge.orig().getX(), edge.orig().getY(), planeOrigin, planeOrientation);
   meshBuilder.addLine(dest, orig, 0.0015, regionColor);
 }
 MeshView meshView = new MeshView(meshBuilder.generateMesh());
 meshView.setMaterial(meshBuilder.generateMaterial());
 meshView.setMouseTransparent(true);
 return meshView;
}

  public JavaFXCoordinateSystem(double length)
  {
   TextureColorPalette1D colorPalette = new TextureColorPalette1D();
   colorPalette.setHueBased(1.0, 1.0);
   JavaFXMultiColorMeshBuilder meshBuilder = new JavaFXMultiColorMeshBuilder(colorPalette);
   double radius = 0.02 * length;
   double coneHeight = 0.10 * length;
   double coneRadius = 0.05 * length;
   meshBuilder.addCylinder(length, radius, new Point3d(), new AxisAngle4d(0.0, 1.0, 0.0, Math.PI / 2.0), Color.RED);
   meshBuilder.addCone(coneHeight, coneRadius, new Point3d(length, 0.0, 0.0), new AxisAngle4d(0.0, 1.0, 0.0, Math.PI / 2.0), Color.RED);
   meshBuilder.addCylinder(length, radius, new Point3d(), new AxisAngle4d(1.0, 0.0, 0.0, -Math.PI / 2.0), Color.GREEN);
   meshBuilder.addCone(coneHeight, coneRadius, new Point3d(0.0, length, 0.0), new AxisAngle4d(1.0, 0.0, 0.0, -Math.PI / 2.0), Color.GREEN);
   meshBuilder.addCylinder(length, radius, new Point3d(), Color.BLUE);
   meshBuilder.addCone(coneHeight, coneRadius, new Point3d(0.0, 0.0, length), Color.BLUE);

   MeshView coordinateSystem = new MeshView(meshBuilder.generateMesh());
   coordinateSystem.setMaterial(meshBuilder.generateMaterial());
   getChildren().addAll(coordinateSystem);
  }
}

  public JavaFXCoordinateSystem(double length)
  {
   TextureColorPalette1D colorPalette = new TextureColorPalette1D();
   colorPalette.setHueBased(1.0, 1.0);
   JavaFXMultiColorMeshBuilder meshBuilder = new JavaFXMultiColorMeshBuilder(colorPalette);
   double radius = 0.02 * length;
   double coneHeight = 0.10 * length;
   double coneRadius = 0.05 * length;
   meshBuilder.addCylinder(length, radius, new Point3D(), new AxisAngle(0.0, 1.0, 0.0, Math.PI / 2.0), Color.RED);
   meshBuilder.addCone(coneHeight, coneRadius, new Point3D(length, 0.0, 0.0), new AxisAngle(0.0, 1.0, 0.0, Math.PI / 2.0), Color.RED);
   meshBuilder.addCylinder(length, radius, new Point3D(), new AxisAngle(1.0, 0.0, 0.0, -Math.PI / 2.0), Color.GREEN);
   meshBuilder.addCone(coneHeight, coneRadius, new Point3D(0.0, length, 0.0), new AxisAngle(1.0, 0.0, 0.0, -Math.PI / 2.0), Color.GREEN);
   meshBuilder.addCylinder(length, radius, new Point3D(), Color.BLUE);
   meshBuilder.addCone(coneHeight, coneRadius, new Point3D(0.0, 0.0, length), Color.BLUE);

   MeshView coordinateSystem = new MeshView(meshBuilder.generateMesh());
   coordinateSystem.setMaterial(meshBuilder.generateMaterial());
   getChildren().addAll(coordinateSystem);
  }
}

private Node createBorderEdgesGraphics(PlanarRegionSegmentationRawData rawData, ConcaveHullFactoryResult concaveHullFactoryResult)
{
 int regionId = rawData.getRegionId();
 JavaFXMultiColorMeshBuilder meshBuilder = new JavaFXMultiColorMeshBuilder(new TextureColorAdaptivePalette(16));
 Point3D planeOrigin = rawData.getOrigin();
 Quaternion planeOrientation = rawData.getOrientation();
 Color regionColor = OcTreeMeshBuilder.getRegionColor(regionId);
 for (ConcaveHullVariables intermediateVariables : concaveHullFactoryResult.getIntermediateVariables())
 {
   Set<QuadEdge> borderEdges = intermediateVariables.getBorderEdges();
   for (QuadEdge edge : borderEdges)
   {
    Point3D dest = PolygonizerTools.toPointInWorld(edge.dest().getX(), edge.dest().getY(), planeOrigin, planeOrientation);
    Point3D orig = PolygonizerTools.toPointInWorld(edge.orig().getX(), edge.orig().getY(), planeOrigin, planeOrientation);
    boolean isEdgeTooLong = dest.distance(orig) > parameters.getEdgeLengthThreshold();
    Color lineColor = Color.hsb(regionColor.getHue(), regionColor.getSaturation(), isEdgeTooLong ? 0.25 : regionColor.getBrightness());
    meshBuilder.addLine(dest, orig, 0.0015, lineColor);
   }
 }
 MeshView meshView = new MeshView(meshBuilder.generateMesh());
 meshView.setMaterial(meshBuilder.generateMaterial());
 meshView.setMouseTransparent(true);
 return meshView;
}

Javadoc

Creates an empty mesh builder using the default texture color palette.

Popular methods of JavaFXMultiColorMeshBuilder

generateMaterial
generateMesh
addLine
Add a 3D line to this builder.
addMesh
Rotates, translates, then combines the given mesh with the mesh contained in this builder.
addMultiLine
Add a series of connected 3D lines to this builder.
clear
Clears the meshes contained in this builder.
addCone
Add a cone to this builder. Its axis is aligned with the z-axis and its top is the vertex with the h
addCube
Add a cube to this builder.
addCylinder
Add a cylinder to this builder. Its axis is aligned with the z-axis in its local coordinate system.
addPolygon
Add a 2D polygon to this builder.
addBox
Add a box to this builder.
setColor

Popular in Java

Creating JSON documents from java classes using gson
scheduleAtFixedRate (ScheduledExecutorService)
startActivity (Activity)
getContentResolver (Context)
BorderLayout (java.awt)
A border layout lays out a container, arranging and resizing its components to fit in five regions:
Component (java.awt)
A component is an object having a graphical representation that can be displayed on the screen and t
GridLayout (java.awt)
The GridLayout class is a layout manager that lays out a container's components in a rectangular gri
BufferedImage (java.awt.image)
The BufferedImage subclass describes an java.awt.Image with an accessible buffer of image data. All
InetAddress (java.net)
An Internet Protocol (IP) address. This can be either an IPv4 address or an IPv6 address, and in pra
Servlet (javax.servlet)
Defines methods that all servlets must implement. A servlet is a small Java program that runs within
Top plugins for WebStorm

How to use us.ihmc.javaFXToolkit.shapes.JavaFXMultiColorMeshBuilderconstructor

Best Java code snippets using us.ihmc.javaFXToolkit.shapes.JavaFXMultiColorMeshBuilder.<init> (Showing top 20 results out of 315)

How to use
us.ihmc.javaFXToolkit.shapes.JavaFXMultiColorMeshBuilder
constructor