Got the road angles configurable and kept the math fast

Author: drewish

SEEME.png

@@ -11,11 +11,12 @@
 #include "cinder/gl/GlslProg.h"
 
 struct RoadOptions {
-    float highwayWidth = 20;
-    float sidestreetWidth = 10;
-    float sidestreetAngle = 0;
-    float blockHeight = 200;
-    float blockWidth = 100;
+    uint8_t highwayWidth = 20;
+    uint8_t sidestreetWidth = 10;
+    int16_t sidestreetAngle1 = 0; // -180 - +180 degrees
+    int16_t sidestreetAngle2 = 90; // -90 - +90 degrees
+    uint16_t blockHeight = 200;
+    uint16_t blockWidth = 100;
 };
 
 struct BlockOptions {

include/Options.h

@@ -41,7 +41,9 @@ class RoadNetwork {
     void buildSideStreets( const Options &options, CGAL::Polygon_set_2<ExactK> &paved );
     void buildBlocks( const Options &options );
 
+    CGAL::Polygon_2<ExactK> roadOutline( const ci::vec2 &a, const ci::vec2 &b, uint8_t width = 10 );
+
     std::vector<ci::vec2> mPoints;
     std::vector<Block> mBlocks;
-    std::vector<FlatShape> mShapes;
+    std::vector<FlatShape> mRoadShapes;
 };

include/Road.h

@@ -83,8 +83,7 @@ void CityscapeApp::buildSky()
 
 void CityscapeApp::setup()
 {
-    mParams = params::InterfaceGl::create( "App parameters", ivec2( 180, 300 ) );
-//    mParams->maximize( false );
+    mParams = params::InterfaceGl::create( "App parameters", ivec2( 350, 700 ) );
 
     resize();
 

include/RoadNetwork.h

@@ -7,20 +7,18 @@
 //
 
 #include "RoadNetwork.h"
-#include "Road.h"
 #include "Lot.h"
-
 #include "CinderCGAL.h"
+#include "GeometryHelpers.h"
 
 using namespace ci;
+using namespace std;
 
 void RoadNetwork::buildHighways( const Options &options, CGAL::Polygon_set_2<ExactK> &paved )
 {
-    float roadWidth = 20.0;
-
-    std::vector<CGAL::Polygon_2<ExactK>> roads;
+    vector<CGAL::Polygon_2<ExactK>> roads;
     for( uint i = 1, size = mPoints.size(); i < size; i += 2 ) {
-        roads.push_back( polygonFrom<ExactK>( Road( mPoints[i-1], mPoints[i], roadWidth ).outline ) );
+        roads.push_back( roadOutline( mPoints[i-1], mPoints[i], options.road.highwayWidth ) );
     }
     // It's more efficient for CGAL to insert all at once:
     paved.join( roads.begin(), roads.end() );
@@ -29,77 +27,91 @@ void RoadNetwork::buildHighways( const Options &options, CGAL::Polygon_set_2<Exa
 // Add some secondary streets
 void RoadNetwork::buildSideStreets( const Options &options, CGAL::Polygon_set_2<ExactK> &paved )
 {
-// TODO:
-//  - make roadway orientation configurable
-
     CGAL::Polygon_set_2<ExactK> unpaved;
-    std::list<CGAL::Polygon_with_holes_2<ExactK>> unpavedPwh;
+    list<CGAL::Polygon_with_holes_2<ExactK>> unpavedPwh;
 
     // Find the unpaved chunks to break up with streets
     unpaved.complement(paved);
-    unpaved.polygons_with_holes( std::back_inserter( unpavedPwh ) );
-    for ( auto chunk = unpavedPwh.begin(); chunk != unpavedPwh.end(); ++chunk ) {
-        if ( chunk->is_unbounded() ) continue;
+    unpaved.polygons_with_holes( back_inserter( unpavedPwh ) );
+    for ( auto chunk : unpavedPwh ) {
+        if ( chunk.is_unbounded() ) continue;
 
-// TODO: this is begging to be moved into a function:
-        // Create narrow roads to cover the bounding box
+        const std::vector<vec2> outlinePoints = polyLineFrom( chunk.outer_boundary() ).getPoints();
+        vector<CGAL::Polygon_2<ExactK>> roads;
 
-        CGAL::Bbox_2 bounds = chunk->bbox();
-        std::vector<CGAL::Polygon_2<ExactK>> roads;
-        for ( float y = bounds.ymin() + options.road.blockHeight; y < bounds.ymax(); y += options.road.blockHeight ) {
-            roads.push_back( polygonFrom<ExactK>( Road( vec2( bounds.xmin(), y ), vec2( bounds.xmax(), y ), options.road.sidestreetWidth).outline ) );
+        // Create narrow roads to cover the bounding box
+        uint16_t angle = options.road.sidestreetAngle1;
+        vector<vec2> dividerPoints = computeDividers( outlinePoints, angle * M_PI / 180.0, options.road.blockHeight );
+        assert( dividerPoints.size() % 2 == 0 );
+        for ( auto a = dividerPoints.cbegin(); a != dividerPoints.cend() ; ++a ) {
+            roads.push_back( roadOutline( *a, *( ++a ), options.road.sidestreetWidth) );
         }
-        for ( float x = bounds.xmin() + options.road.blockWidth; x < bounds.xmax(); x += options.road.blockWidth ) {
-            roads.push_back( polygonFrom<ExactK>( Road( vec2( x, bounds.ymin() ), vec2( x, bounds.ymax() ), options.road.sidestreetWidth).outline ) );
+
+        angle += options.road.sidestreetAngle2;
+        // TODO move duplicated logic to a function
+        dividerPoints =  computeDividers( outlinePoints, angle * M_PI / 180.0, options.road.blockWidth );
+        assert( dividerPoints.size() % 2 == 0 );
+        for ( auto a = dividerPoints.cbegin(); a != dividerPoints.cend() ; ++a ) {
+            roads.push_back( roadOutline( *a, *( ++a ), options.road.sidestreetWidth) );
         }
 
         CGAL::Polygon_set_2<ExactK> newStreets;
-        // It's more efficient for CGAL to insert all at once:
         newStreets.join( roads.begin(), roads.end() );
-
         // Find the intersection of the streets and block
-        newStreets.intersection( *chunk );
-
+        newStreets.intersection( chunk );
         // Add those as new streets.
         paved.join( newStreets );
     }
-
 }
 
 // Should probably be called build the rest... a bit of a code smell here.
 void RoadNetwork::buildBlocks( const Options &options )
 {
     CGAL::Polygon_set_2<ExactK> paved, unpaved;
-    std::list<CGAL::Polygon_with_holes_2<ExactK>> pavedShapes, unpavedShapes;
+    list<CGAL::Polygon_with_holes_2<ExactK>> pavedShapes, unpavedShapes;
 
     buildHighways( options, paved );
     // TODO: Make this step optional
     buildSideStreets( options, paved );
 
     // Get the expanded street network
-    paved.polygons_with_holes( std::back_inserter( pavedShapes ) );
-    for ( auto it = pavedShapes.begin(); it != pavedShapes.end(); ++it ) {
-        mShapes.push_back( FlatShape( *it ) );
+    paved.polygons_with_holes( back_inserter( pavedShapes ) );
+    for ( auto &it : pavedShapes ) {
+        mRoadShapes.push_back( FlatShape( it ) );
     }
 
     // Extract the final blocks
     unpavedShapes.clear();
     unpaved.complement(paved);
-    unpaved.polygons_with_holes( std::back_inserter( unpavedShapes ) );
-    for ( auto it = unpavedShapes.begin(); it != unpavedShapes.end(); ++it ) {
-        if ( it->is_unbounded() ) continue;
+    unpaved.polygons_with_holes( back_inserter( unpavedShapes ) );
+    for ( auto &it : unpavedShapes ) {
+        if ( it.is_unbounded() ) continue;
 
-        mBlocks.push_back( Block( FlatShape( *it ), ColorA( 1.0, 1.0, 0.0, 0.3 ) ) );
+        mBlocks.push_back( Block( FlatShape( it ), ColorA( 1.0, 1.0, 0.0, 0.3 ) ) );
     }
 }
 
+CGAL::Polygon_2<ExactK> RoadNetwork::roadOutline( const ci::vec2 &a, const ci::vec2 &b, uint8_t width )
+{
+    // It's much faster to do this math outside of CGAL.
+    ci::vec2 perpendicular = glm::normalize( ci::vec2( b.y - a.y, -( b.x - a.x ) ) );
+    ci::vec2 offset = perpendicular * ci::vec2( width / 2.0 );
+
+    CGAL::Polygon_2<ExactK> results;
+    results.push_back( pointFrom<ExactK>( b + offset ) );
+    results.push_back( pointFrom<ExactK>( b - offset ) );
+    results.push_back( pointFrom<ExactK>( a - offset ) );
+    results.push_back( pointFrom<ExactK>( a + offset ) );
+    return results;
+};
+
 void RoadNetwork::layout( const Options &options )
 {
     // Don't bother redoing the layout if we have an odd number of points.
     if ( mPoints.size() % 2 == 1 ) return;
 
     mBlocks.clear();
-    mShapes.clear();
+    mRoadShapes.clear();
 
     buildBlocks( options );
 
@@ -112,7 +124,7 @@ void RoadNetwork::draw( const Options &options )
 {
     if ( options.drawRoads ) {
         gl::color( ColorA( 0.3f, 0.3f, 0.3f, 0.4f ) );
-        for ( auto &shape : mShapes ) {
+        for ( auto &shape : mRoadShapes ) {
             gl::draw( shape.mesh() );
         }
     }

src/CityscapeApp.cpp

@@ -13,10 +13,16 @@ void CityMode::addParams( ci::params::InterfaceGlRef params) {
 
     // TODO: Don't redo layout on every change, set a timer to update every half
     // second or so.
-    //    params->addParam( "highwayWidth", &mOptions.road.highwayWidth )
-    //        .min( 10 ).max( 50 ).step( 1 ).updateFn( std::bind( &CityMode::layout, this ) );
-    //    params->addParam( "sidestreetWidth", &mOptions.road.sidestreetWidth )
-    //        .min( 10 ).max( 50 ).step( 1 ).updateFn( std::bind( &CityMode::layout, this ) );
+    params->addParam( "highwayWidth", &mOptions.road.highwayWidth )
+        .min( 10 ).max( 50 ).step( 1 ).updateFn( std::bind( &CityMode::layout, this ) );
+    params->addParam( "sidestreetWidth", &mOptions.road.sidestreetWidth )
+        .min( 10 ).max( 50 ).step( 1 ).updateFn( std::bind( &CityMode::layout, this ) );
+    params->addParam( "highwayWidth", &mOptions.road.highwayWidth )
+        .min( 10 ).max( 50 ).step( 1 ).updateFn( std::bind( &CityMode::layout, this ) );
+    params->addParam( "sidestreetAngle1", &mOptions.road.sidestreetAngle1 )
+        .min( -180 ).max( 180 ).step( 5 ).updateFn( std::bind( &CityMode::layout, this ) );
+    params->addParam( "sidestreetAngle2", &mOptions.road.sidestreetAngle2 )
+        .min( -90 ).max( 90 ).step( 15 ).updateFn( std::bind( &CityMode::layout, this ) );
     params->addParam( "blockWidth", &mOptions.road.blockWidth ).step( 5 )
         .min( 15 ).max( 400 ).updateFn( std::bind( &CityMode::layout, this ) );
     params->addParam( "blockHeight", &mOptions.road.blockHeight ).step( 5 )

src/RoadNetwork.cpp

@@ -103,7 +103,6 @@
 		5FEFD9D81A92FB450093F109 /* Block.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; name = Block.h; path = ../include/Block.h; sourceTree = "<group>"; };
 		5FEFD9D91A92FB450093F109 /* Building.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = Building.h; sourceTree = "<group>"; };
 		5FEFD9DA1A92FB450093F109 /* Lot.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; name = Lot.h; path = ../include/Lot.h; sourceTree = "<group>"; };
-		5FEFD9DB1A92FB450093F109 /* Road.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; name = Road.h; path = ../include/Road.h; sourceTree = "<group>"; };
 		87F1E1C66EC543B1852B8B39 /* Cityscape_Prefix.pch */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.h; name = Cityscape_Prefix.pch; path = ../xcode/Cityscape_Prefix.pch; sourceTree = "<group>"; };
 		8D1107320486CEB800E47090 /* Cityscape.app */ = {isa = PBXFileReference; explicitFileType = wrapper.application; includeInIndex = 0; path = Cityscape.app; sourceTree = BUILT_PRODUCTS_DIR; };
 		ACB4D9448A764F68A540CED0 /* Info.plist */ = {isa = PBXFileReference; lastKnownFileType = text.plist.xml; path = Info.plist; sourceTree = "<group>"; };
@@ -223,7 +222,6 @@
 				5FA88B2B1C48B866008C1A4A /* CityMode.h */,
 				5FA88B2E1C48B95F008C1A4A /* BlockMode.h */,
 				5FA88B2F1C48B9A6008C1A4A /* BuildingMode.h */,
-				5FEFD9DB1A92FB450093F109 /* Road.h */,
 				498D89CB1B1C027300A962B5 /* RoadNetwork.h */,
 				5FEFD9D81A92FB450093F109 /* Block.h */,
 				5FEFD9DA1A92FB450093F109 /* Lot.h */,