How to use

BuildingParser

in

kendzi.josm.kendzi3d.jogl.model.building.parser

private static List<BuildingPart> parseRelationClone(Way primitive, BuildingPart bp) {
  List<RelationCloneHeight> buildHeightClone = RelationCloneHeight.buildHeightClone(primitive);
  List<BuildingPart> bpList = new ArrayList<BuildingPart>();
  for (RelationCloneHeight relationCloneHeight : buildHeightClone) {
    for (Double height : relationCloneHeight) {
      bpList.add(cloneBuildingPart(bp, height));
    }
  }
  return bpList;
}

private static boolean isNodeBuildingPart(Node node) {
  if (isPrimitiveBuildingPart(node)
      && OsmAttributeKeys.BUILDING_SHAPE.primitiveKeyHaveValue(node, OsmAttributeValues.SPHERE)) {
    return true;
  }
  return false;
}

public static BuildingModel parseBuilding(OsmPrimitive primitive, Perspective perspective) {
  if (primitive instanceof Way) {
    return BuildingParser.parseBuildingWay((Way) primitive, perspective);
  } else if (primitive instanceof Node) {
    return BuildingParser.parseBuildingNode((Node) primitive, perspective);
  } else if (primitive instanceof Relation) {
    Relation relation = (Relation) primitive;
    if (relation.isMultipolygon()) {
      // simple building from multipolygon
      return BuildingParser.parseBuildingMultiPolygon(relation, perspective);
    } else {
      // complex building
      return BuildingParser.parseBuildingRelation(relation, perspective);
    }
  }
  throw new IllegalArgumentException("unknown type of building");
}

if (isRelationHaveBuildingParts(pRelation)) {
  bt = BuildingType.PARTS;
  } else if (BuildingType.PARTS.equals(bt) && !isPrimitiveBuildingPart(member.getMember())) {
    continue;
    bps.addAll(parseBuildingPart((Way) primitive, pers));
  } else if (primitive instanceof Node && isNodeBuildingPart((Node) primitive)) {
    nbps.addAll(parseBuildingPart((Node) primitive, pers));
      List<BuildingPart> bp = parseBuildingMultiPolygonPart((Relation) primitive, pers);
      if (bp != null) {
        bps.addAll(bp);

if (isAttribute(node, OsmAttributeKeys.BUILDING, OsmAttributeValues.ENTRANCE)
    || isAnyAttribute(node, OsmAttributeKeys.ENTRANCE)) {
  entrance.setWidth(parseWidth(node, entrance.getWidth()));
    for (Double cloner : rch) {
      EntranceBuildingElement beClone = (EntranceBuildingElement) clone(entrance);
if (isAttribute(node, OsmAttributeKeys.BUILDING, OsmAttributeValues.WINDOW)) {
  entrance.setMinHeight(ModelUtil.getMinHeight(node, entrance.getMinHeight()));
  entrance.setWidth(parseWidth(node, entrance.getWidth()));
    for (Double cloner : rch) {
      WindowBuildingElement beClone = (WindowBuildingElement) clone(entrance);

private static WallPart parseWallPart(ReversableWay rw, Perspective pPerspective) {
  Way way = rw.getWay();
  WallPart wp = new WallPart();
  List<WallNode> wnList = new ArrayList<WallNode>();
  if (!rw.isReversed()) {
    for (int i = 0; i < way.getNodesCount(); i++) {
      WallNode wn = parseWallNode(way.getNode(i), pPerspective);
      wnList.add(wn);
    }
  } else {
    for (int i = way.getNodesCount() - 1; i >= 0; i--) {
      WallNode wn = parseWallNode(way.getNode(i), pPerspective);
      wnList.add(wn);
    }
  }
  wp.setNodes(wnList);
  wp.setBuildingElements(parseBuildingAttributeWallElement(way));
  // String parseFacadeName =
  // BuildingAttributeParser.parseFacadeMaterialName(w);
  // wp.setFacadeTextureData(BuildingAttributeParser.parseFacadeTexture(parseFacadeName,
  // this.textureLibraryService));
  // wp.setColor(BuildingAttributeParser.parseFacadeColor(w));
  wp.setFacadeMaterialType(BuildingAttributeParser.parseFacadeMaterialName(way));
  wp.setFacadeColor(BuildingAttributeParser.parseFacadeColor(way));
  wp.setRoofMaterialType(BuildingAttributeParser.parseRoofMaterialName(way));
  wp.setRoofColor(BuildingAttributeParser.parseRoofColor(way));
  return wp;
}

@Override
public void buildWorldObject() {
  BuildingModel bm = this.bm;
  if (!preview || bm == null) {
    bm = BuildingParser.parseBuilding(primitive, perspective);
    if (primitive instanceof Node || primitive instanceof Way) {
      selection = parseSelection(primitive.getUniqueId(), bm);
    }
    this.bm = bm;
  }
  preview = false;
  if (bm != null) {
    BuildingElementsTextureManager tm = new CacheOsmBuildingElementsTextureMenager(textureLibraryStorageService);
    BuildingOutput buildModel = BuildingBuilder.buildModel(bm, tm);
    Model model = buildModel.getModel();
    model.useLight = true;
    model.useTexture = true;
    this.model = model;
    this.buildModel = true;
    debug = prepareDebugInformation(buildModel);
  }
}

private static boolean isRelationHaveBuildingParts(Relation pRelation) {
  boolean haveParts = false;
  for (int i = 0; i < pRelation.getMembersCount(); i++) {
    RelationMember member = pRelation.getMember(i);
    if (isPrimitiveBuildingPart(member.getMember())) {
      haveParts = true;
      break;
    }
  }
  return haveParts;
}