Thread: [Bprocessor-commit] facade/src/net/sourceforge/bprocessor/facade/command Facade.java, NONE, 1.1 pa

SourceForge Headquarters 225 Broadway Suite 1600 San Diego, CA 92101 +1 (858) 422-6466

Update of /cvsroot/bprocessor/facade/src/net/sourceforge/bprocessor/facade/command
In directory sfp-cvsdas-2.v30.ch3.sourceforge.com:/tmp/cvs-serv12846/src/net/sourceforge/bprocessor/facade/command

Added Files:
	Facade.java package.html 
Log Message:


--- NEW FILE: package.html ---
<body>
Defines the package that contains the facade module
</body>
--- NEW FILE: Facade.java ---
//---------------------------------------------------------------------------------
// $Id: Facade.java,v 1.1 2010/07/13 09:32:46 henryml Exp $
//
// Copyright (c) 2005      The BProcessor Team (http://bprocessor.sourceforge.net) 
// Released under the Lesser GNU Public License v2.1
//---------------------------------------------------------------------------------

package net.sourceforge.bprocessor.facade.command;

import java.util.Collection;
import java.util.HashMap;
import java.util.HashSet;
import java.util.LinkedList;
import java.util.List;
import java.util.Map;
import java.util.Set;

import net.sourceforge.bprocessor.model.Attribute;
import net.sourceforge.bprocessor.model.Command;
import net.sourceforge.bprocessor.model.Edge;
import net.sourceforge.bprocessor.model.Geometry;
import net.sourceforge.bprocessor.model.ParameterBlock;
import net.sourceforge.bprocessor.model.Project;
import net.sourceforge.bprocessor.model.Selector;
import net.sourceforge.bprocessor.model.Space;
import net.sourceforge.bprocessor.model.Surface;
import net.sourceforge.bprocessor.model.Vertex;

/**
 * 
 */
public class Facade extends Command {
  
  /**
   * {@inheritDoc}
   */
  public String title() {
    return "Facade";
  }
  
  /**
   * Constructor
   * @param net Net
   */
  public Facade(Space net) {
    parameters.put("net", net);
    parameters.put("frame-width", 0.045);
    parameters.put("depth", 0.12);
  }
  
  /**
   * {@inheritDoc}
   */
  public void evaluate() {
    HashMap<String, Object> env = parameters.evaluate(new HashMap());
    Space net = (Space) env.get("net");
    double frameWidth = (Double) env.get("frame-width");
    double depth = (Double) env.get("depth");
    Space owner = net.getOwner();
    Space union = (Space) owner.find("Interior");
    if (union == null) {
      union = Space.createUnion("Interior");
      owner.add(union);
    }
    union.clear();
    prepareNet(net, frameWidth);
    createSingleFacade(net, union, depth);
    Project.getInstance().changed();
  }
  
  private void prepareNet(Space n, double frameWidth) {
    Collection<Edge> edges = n.getEdges();
    for (Edge e : edges) {
      ParameterBlock parameters = e.getParameters();
      if (parameters == null) {
        parameters = new ParameterBlock();
        e.setParameters(parameters);
      }
      Map env = parameters.environment();
      if (env.get("width") == null) {
        parameters.putDouble("width", frameWidth);
      }
    }
    for (Surface s : n.getSurfaces()) {
      ParameterBlock parameters = s.getParameters();
      if (parameters == null) {
        parameters = new ParameterBlock();
        s.setParameters(parameters);
      }
      Map env = parameters.environment();
      if (env.get("type") == null) {
        List options = new LinkedList();
        options.add("Glass");
        options.add("Window");
        options.add("Door");
        Selector sel = new Selector(options);
        sel.setCurrentValue("Glass");
        parameters.put(new Attribute("type", sel));
      }
    }
  }
  
  private void createSingleFacade(Space net, Space space, double depth) {
    Space frame = Space.createConstructionSpace("Frame");
    space.add(frame);
    
    if (net != null) {
      List<Edge> outline = netOutline(net);
      List<Edge> outlineCopies = new LinkedList<Edge>();
      for (Edge e : outline) {
        outlineCopies.add(e.copy());
      }
      if (!outlineCopies.isEmpty()) {        
        /* make the shell of the facade */
        Surface frameSurface = new Surface(outlineCopies);
        frameSurface = space.insert(frameSurface);
        //Geometry.assignSame(front, frameSurface, space, frame);
        Set sides1 = new HashSet();
        Surface frameSurfEx = extrudeIntoSpace(space, frameSurface, depth, sides1);
        Geometry.holeAnalysis(frameSurfEx);
        for (Surface field : net.getSurfaces()) {
          Map<Edge, Double> offsetMap = new HashMap<Edge, Double>();
          Map envF = field.getParameters().environment();           
          for (Edge e : field.getEdges()) {
            Map envE = e.getParameters().environment();
            double width = ((Double)envE.get("width")).doubleValue();
            if (outline.contains(e)) {
              offsetMap.put(e, -width);
            } else {
              offsetMap.put(e, -(width / 2));
            }
          }
          
          Surface hole = new Surface(Edge.placeOffset(field.getEdges(), field, offsetMap));
          hole = space.insert(hole);
          Space holeSpace = Space.createFunctionalSpace("Facade Hole");
          space.add(holeSpace);
          //Geometry.assignSame(front, hole, space, holeSpace);          
          Geometry.holeAnalysis(hole);
          
          Set sides2 = new HashSet();
          Surface holeEx = space.insert(extrudeIntoSpace(space, hole, depth, sides2));
          //assignOpposite(front, holeEx, space, holeSpace);
          Geometry.holeAnalysis(holeEx);
          //detailField(envF, hole, holeSpace);
        }
      }
    }
  }
  
  private Surface extrudeIntoSpace(Space space, Surface s, double delta, Set<Surface> sides) {
    int deltaCorrection = 1;
//    if (s.normal().dot(front.normal()) < 0) {
//      deltaCorrection *= -1;
//    }
//    if (front.getFrontDomain() != space) {
//      deltaCorrection *= -1;
//    }
    Set<Surface> tops = new HashSet<Surface>();
    Surface top = s.extrusionall(delta * deltaCorrection, sides, tops);
    tops.addAll(sides);
    for (Surface surface : tops) {
      for (Edge edge : surface.getEdges()) {
        space.add(edge.getTo());
        space.add(edge.getFrom());
        space.add(edge);
      }
      space.add(surface);
    }
    return top;    
  }
  
  
  private List<Edge> netOutline(Space net) {
    /*Find outer edges*/
    Set<Edge> outer = new HashSet<Edge>();
    for (Edge current : net.getEdges()) {
      if (current.getSurfaces().size() == 1) {
        outer.add(current);
      }
    }
    /*If there are outer edges sort them in order*/
    if (!outer.isEmpty()) {
      LinkedList<Edge> outline = new LinkedList<Edge>();
      Edge first = (Edge)outer.iterator().next();
      outline.add(first);
      outer.remove(first);
      Vertex nextVertex = first.getTo();
      boolean doneAll = false;
      while (!doneAll) {
        Edge next = null;
        for (Edge e : nextVertex.getEdges()) {
          if (outer.contains(e)) {
            next = (Edge)e;
            break;
          }
        }
        if (next != null) {
          outer.remove(next);
          nextVertex = next.otherVertex(nextVertex);
          outline.add(next);
        } else {
          doneAll = true;
        }
      }
      /*If all outer edges are in the outline, 
       * and the last edge is connected to the first, 
       * return the outline */
      if (outer.isEmpty() && 
          first.getFrom().getEdges().contains(outline.getLast())) {        
        return outline;
      }
    }
    return new LinkedList<Edge>();
  }
}

Thread: [Bprocessor-commit] facade/src/net/sourceforge/bprocessor/facade/command Facade.java, NONE, 1.1 pa

bprocessor-commit