Improve line zoning

src/Geometry.hs

@@ -15,6 +15,7 @@ module Geometry
     , module Geometry.Bezier
     , module Geometry.Vector
     , module Geometry.LHS
+    --, module Geometry.Zone
     )
     where
 import Geometry.Data
@@ -22,11 +23,9 @@ import Geometry.Intersect
 import Geometry.Bezier
 import Geometry.Vector
 import Geometry.LHS
+--import Geometry.Zone
 
---import Data.Function
 import Data.List
-import Data.Maybe
---import Control.Applicative
 -- | Return a point a distance away from a first point towards a second point.
 -- Does not go past the second point.
 alongSegBy :: Float -> Point2 -> Point2 -> Point2
@@ -191,48 +190,6 @@ doublePair (x,y) = [(x,y),(y,x)]
 
 doubleV2 :: V2 a -> [V2 a]
 doubleV2 (V2 x y) = [V2 x y,V2 y x]
-
--- | Test whether two polygons intersect by testing the intersection of each
--- consecutive pair of points.
---polysIntersect :: [Point2] -> [Point2] -> Bool
---{-# INLINE polysIntersect #-}
---polysIntersect (p:ps) (q:qs) 
---    -- = any isJust $ (\(V2 a b) (V2 c d) -> myIntersectSegSeg a b c d) <$> pairs1 <*> pairs2
---    = or $ (\(V2 a b) (V2 c d) -> isJust $ myIntersectSegSeg a b c d) <$> pairs1 <*> pairs2
---  where 
---    pairs1 = zipWith V2 (p:ps) (ps++[p])
---    pairs2 = zipWith V2 (q:qs) (qs++[q])
---polysIntersect _ _ = False
-
-polysIntersect :: [Point2] -> [Point2] -> Bool
-polysIntersect (a:b:xs) ps = go a (a:b:xs) ps
-  where
-    go x' (a':b':xs') ps' = pairPolyIntersect a' b' ps' || go x' (b':xs') ps'
-    go b' (a':[]) ps' = pairPolyIntersect a' b' ps'
-    go _ _ _ = False
-polysIntersect _ _ = False
-
-pairPolyIntersect :: Point2 -> Point2 -> [Point2] -> Bool
-pairPolyIntersect a' b' (c':d':xs') = go c' a' b' (c':d':xs')
-  where
-    go x a b (c:d:xs) 
-        | isJust $ myIntersectSegSeg a b c d = True
-        | otherwise = go x a b (d:xs)
-    go d a b (c:[]) = isJust $ myIntersectSegSeg a b c d
-    go _ _ _ _ = False
-pairPolyIntersect _ _ _ = False
-
--- | Test whether two polygons intersect or if one is contained in the other.
-polysOverlap :: [Point2] -> [Point2] -> Bool
-polysOverlap (p:ps) (q:qs) = pointInPolygon p (q:qs)
-    || pointInPolygon q (p:ps)
-    || polysIntersect (p:ps) (q:qs) 
-polysOverlap _ _ = False
--- | Test whether any polygons from a first list intersect with any polygons from
--- a second list.
-anyPolyssIntersect :: [[Point2]] -> [[Point2]] -> Bool
-anyPolyssIntersect x y = or $ polysIntersect <$> x <*> y
-
 -- split a list into triples, forms triangles from a polygon
 polyToTris :: [s] -> [s]
 {-# INLINE polyToTris #-}
@@ -394,10 +351,11 @@ divideLineExact x a b = map ( (a +.+ ) . ( *.* v) ) [0 , x .. d]
     d = dist a b
     v = normalizeV $ b -.- a
 
+
 -- | Given two pairs of Ints, returns a list of pairs of Ints that form 
 -- a digital line between them.
 digitalLine :: (Int,Int) -> (Int,Int) -> [(Int,Int)]
-{-# INLINE digitalLine #-}
+--{-# INLINE digitalLine #-}
 digitalLine (x1,y1) (x2,y2) 
     | abs (x1-x2) > abs (y1-y2) = 
         [ (x,( (y1-y2) * x + x1*y2 - x2*y1) `rdiv` (x1-x2) ) 
@@ -421,8 +379,9 @@ digitalRect (a,b) (c,d) = [(s,t) | s <- [minx .. maxx] , t <- [miny .. maxy]]
     miny = min b d
 -- | Given two Ints, creates the list of Ints between these.
 intervalList :: Int -> Int -> [Int]
+{-# INLINE intervalList #-}
 intervalList x y 
-    | y >= x = [x .. y]
+    | y > x = [x .. y]
     | otherwise = reverse [y..x]
 -- | Create points on the circumference of a circle with maximal distance
 -- between them.