{-# LINE 1 "src/Geometry/HCDT/Triangulation.hsc" #-}
{-# LANGUAGE ForeignFunctionInterface #-}
{-# LANGUAGE CPP #-}
module Geometry.HCDT.Triangulation
( cTriangulationToTriangulation
, cCTriangulationToConstrainedTriangulation
, vertexToCVertex
, edgeToCEdge
, c_delaunay 
, c_cdelaunay
, CTriangulation (..)
, CVertex (..)
, CCTriangulation (..)
, CEdge (..) )
  where
import           Geometry.HCDT.Types
import           Foreign
import           Foreign.C.Types
import qualified Data.IntMap.Strict as IM



data CVertex = CVertex {
    CVertex -> CDouble
__x :: CDouble
  , CVertex -> CDouble
__y :: CDouble
}

instance Storable CVertex where
    sizeOf :: CVertex -> Int
sizeOf    CVertex
__ = (Int
16)
{-# LINE 29 "src/Geometry/HCDT/Triangulation.hsc" #-}
    alignment __ = 8
{-# LINE 30 "src/Geometry/HCDT/Triangulation.hsc" #-}
    peek ptr = do
      x'  <- (\hsc_ptr -> peekByteOff hsc_ptr 0) ptr
{-# LINE 32 "src/Geometry/HCDT/Triangulation.hsc" #-}
      y'  <- (\hsc_ptr -> peekByteOff hsc_ptr 8) ptr
{-# LINE 33 "src/Geometry/HCDT/Triangulation.hsc" #-}
      return CVertex { __x = x', __y = y' }
    poke :: Ptr CVertex -> CVertex -> IO ()
poke Ptr CVertex
ptr (CVertex CDouble
r1 CDouble
r2)
      = do
        (\Ptr CVertex
hsc_ptr -> forall a b. Storable a => Ptr b -> Int -> a -> IO ()
pokeByteOff Ptr CVertex
hsc_ptr Int
0) Ptr CVertex
ptr CDouble
r1
{-# LINE 37 "src/Geometry/HCDT/Triangulation.hsc" #-}
        (\Ptr CVertex
hsc_ptr -> forall a b. Storable a => Ptr b -> Int -> a -> IO ()
pokeByteOff Ptr CVertex
hsc_ptr Int
8) Ptr CVertex
ptr CDouble
r2
{-# LINE 38 "src/Geometry/HCDT/Triangulation.hsc" #-}

cVertexToVertex :: CVertex -> IO Vertex
cVertexToVertex :: CVertex -> IO Vertex
cVertexToVertex CVertex
cvertex = do
  let x :: Double
x = forall a b. (Real a, Fractional b) => a -> b
realToFrac forall a b. (a -> b) -> a -> b
$ CVertex -> CDouble
__x CVertex
cvertex
  let y :: Double
y = forall a b. (Real a, Fractional b) => a -> b
realToFrac forall a b. (a -> b) -> a -> b
$ CVertex -> CDouble
__y CVertex
cvertex
  forall (m :: * -> *) a. Monad m => a -> m a
return forall a b. (a -> b) -> a -> b
$ Double -> Double -> Vertex
Vertex Double
x Double
y

vertexToCVertex :: Vertex -> IO CVertex
vertexToCVertex :: Vertex -> IO CVertex
vertexToCVertex (Vertex Double
x Double
y) = do
  forall (m :: * -> *) a. Monad m => a -> m a
return forall a b. (a -> b) -> a -> b
$ CVertex { __x :: CDouble
__x = forall a b. (Real a, Fractional b) => a -> b
realToFrac Double
x, __y :: CDouble
__y = forall a b. (Real a, Fractional b) => a -> b
realToFrac Double
y }

data CEdge = CEdge {
    CEdge -> CUInt
__i :: CUInt
  , CEdge -> CUInt
__j :: CUInt
}

instance Storable CEdge where
    sizeOf :: CEdge -> Int
sizeOf    CEdge
__ = (Int
8)
{-# LINE 56 "src/Geometry/HCDT/Triangulation.hsc" #-}
    alignment __ = 4
{-# LINE 57 "src/Geometry/HCDT/Triangulation.hsc" #-}
    peek ptr = do
      i'  <- (\hsc_ptr -> peekByteOff hsc_ptr 0) ptr
{-# LINE 59 "src/Geometry/HCDT/Triangulation.hsc" #-}
      j'  <- (\hsc_ptr -> peekByteOff hsc_ptr 4) ptr
{-# LINE 60 "src/Geometry/HCDT/Triangulation.hsc" #-}
      return CEdge { __i = i'
                   , __j = j' }
    poke :: Ptr CEdge -> CEdge -> IO ()
poke Ptr CEdge
ptr (CEdge CUInt
r1 CUInt
r2)
      = do
        (\Ptr CEdge
hsc_ptr -> forall a b. Storable a => Ptr b -> Int -> a -> IO ()
pokeByteOff Ptr CEdge
hsc_ptr Int
0) Ptr CEdge
ptr CUInt
r1
{-# LINE 65 "src/Geometry/HCDT/Triangulation.hsc" #-}
        (\Ptr CEdge
hsc_ptr -> forall a b. Storable a => Ptr b -> Int -> a -> IO ()
pokeByteOff Ptr CEdge
hsc_ptr Int
4) Ptr CEdge
ptr CUInt
r2
{-# LINE 66 "src/Geometry/HCDT/Triangulation.hsc" #-}

cEdgeToEdge :: CEdge -> IO Edge
cEdgeToEdge :: CEdge -> IO Edge
cEdgeToEdge CEdge
cedge = do
  let i :: Int
i = forall a b. (Integral a, Num b) => a -> b
fromIntegral forall a b. (a -> b) -> a -> b
$ CEdge -> CUInt
__i CEdge
cedge
  let j :: Int
j = forall a b. (Integral a, Num b) => a -> b
fromIntegral forall a b. (a -> b) -> a -> b
$ CEdge -> CUInt
__j CEdge
cedge
  forall (m :: * -> *) a. Monad m => a -> m a
return forall a b. (a -> b) -> a -> b
$ Int -> Int -> Edge
Edge Int
i Int
j

edgeToCEdge :: Edge -> IO CEdge
edgeToCEdge :: Edge -> IO CEdge
edgeToCEdge (Edge Int
i Int
j) = do
  forall (m :: * -> *) a. Monad m => a -> m a
return forall a b. (a -> b) -> a -> b
$ CEdge { __i :: CUInt
__i = forall a b. (Integral a, Num b) => a -> b
fromIntegral Int
i, __j :: CUInt
__j = forall a b. (Integral a, Num b) => a -> b
fromIntegral Int
j }

data CTriangle = CTriangle {
    CTriangle -> CUInt
__i1 :: CUInt
  , CTriangle -> CUInt
__i2 :: CUInt
  , CTriangle -> CUInt
__i3 :: CUInt
}

instance Storable CTriangle where
    sizeOf :: CTriangle -> Int
sizeOf    CTriangle
__ = (Int
12)
{-# LINE 85 "src/Geometry/HCDT/Triangulation.hsc" #-}
    alignment __ = 4
{-# LINE 86 "src/Geometry/HCDT/Triangulation.hsc" #-}
    peek ptr = do
      i1'  <- (\hsc_ptr -> peekByteOff hsc_ptr 0) ptr
{-# LINE 88 "src/Geometry/HCDT/Triangulation.hsc" #-}
      i2'  <- (\hsc_ptr -> peekByteOff hsc_ptr 4) ptr
{-# LINE 89 "src/Geometry/HCDT/Triangulation.hsc" #-}
      i3'  <- (\hsc_ptr -> peekByteOff hsc_ptr 8) ptr
{-# LINE 90 "src/Geometry/HCDT/Triangulation.hsc" #-}
      return CTriangle { __i1 = i1'
                       , __i2 = i2'
                       , __i3 = i3' }
    poke :: Ptr CTriangle -> CTriangle -> IO ()
poke Ptr CTriangle
ptr (CTriangle CUInt
r1 CUInt
r2 CUInt
r3)
      = do
        (\Ptr CTriangle
hsc_ptr -> forall a b. Storable a => Ptr b -> Int -> a -> IO ()
pokeByteOff Ptr CTriangle
hsc_ptr Int
0) Ptr CTriangle
ptr CUInt
r1
{-# LINE 96 "src/Geometry/HCDT/Triangulation.hsc" #-}
        (\Ptr CTriangle
hsc_ptr -> forall a b. Storable a => Ptr b -> Int -> a -> IO ()
pokeByteOff Ptr CTriangle
hsc_ptr Int
4) Ptr CTriangle
ptr CUInt
r2
{-# LINE 97 "src/Geometry/HCDT/Triangulation.hsc" #-}
        (\Ptr CTriangle
hsc_ptr -> forall a b. Storable a => Ptr b -> Int -> a -> IO ()
pokeByteOff Ptr CTriangle
hsc_ptr Int
8) Ptr CTriangle
ptr CUInt
r3
{-# LINE 98 "src/Geometry/HCDT/Triangulation.hsc" #-}

cTriangleToTriangle :: CTriangle -> IO Triangle
cTriangleToTriangle :: CTriangle -> IO Triangle
cTriangleToTriangle CTriangle
ctriangle = do
  let i1 :: Int
i1 = forall a b. (Integral a, Num b) => a -> b
fromIntegral forall a b. (a -> b) -> a -> b
$ CTriangle -> CUInt
__i1 CTriangle
ctriangle
  let i2 :: Int
i2 = forall a b. (Integral a, Num b) => a -> b
fromIntegral forall a b. (a -> b) -> a -> b
$ CTriangle -> CUInt
__i2 CTriangle
ctriangle
  let i3 :: Int
i3 = forall a b. (Integral a, Num b) => a -> b
fromIntegral forall a b. (a -> b) -> a -> b
$ CTriangle -> CUInt
__i3 CTriangle
ctriangle
  forall (m :: * -> *) a. Monad m => a -> m a
return forall a b. (a -> b) -> a -> b
$ Int -> Int -> Int -> Triangle
Triangle Int
i1 Int
i2 Int
i3

data CTriangulation = CTriangulation {
    CTriangulation -> Ptr CVertex
__vertices   :: Ptr CVertex
  , CTriangulation -> CSize
__nvertices  :: CSize
  , CTriangulation -> Ptr CTriangle
__triangles  :: Ptr CTriangle
  , CTriangulation -> CSize
__ntriangles :: CSize
  , CTriangulation -> Ptr CEdge
__edges      :: Ptr CEdge
  , CTriangulation -> CSize
__nedges     :: CSize
}

instance Storable CTriangulation where
    sizeOf :: CTriangulation -> Int
sizeOf    CTriangulation
__ = (Int
48)
{-# LINE 117 "src/Geometry/HCDT/Triangulation.hsc" #-}
    alignment __ = 8
{-# LINE 118 "src/Geometry/HCDT/Triangulation.hsc" #-}
    peek ptr = do
      vs  <- (\hsc_ptr -> peekByteOff hsc_ptr 0) ptr
{-# LINE 120 "src/Geometry/HCDT/Triangulation.hsc" #-}
      nvs <- (\hsc_ptr -> peekByteOff hsc_ptr 8) ptr
{-# LINE 121 "src/Geometry/HCDT/Triangulation.hsc" #-}
      ts  <- (\hsc_ptr -> peekByteOff hsc_ptr 16) ptr
{-# LINE 122 "src/Geometry/HCDT/Triangulation.hsc" #-}
      nts <- (\hsc_ptr -> peekByteOff hsc_ptr 24) ptr
{-# LINE 123 "src/Geometry/HCDT/Triangulation.hsc" #-}
      es  <- (\hsc_ptr -> peekByteOff hsc_ptr 32) ptr
{-# LINE 124 "src/Geometry/HCDT/Triangulation.hsc" #-}
      nes <- (\hsc_ptr -> peekByteOff hsc_ptr 40) ptr
{-# LINE 125 "src/Geometry/HCDT/Triangulation.hsc" #-}
      return CTriangulation { __vertices   = vs
                            , __nvertices  = nvs
                            , __triangles  = ts
                            , __ntriangles = nts
                            , __edges      = es
                            , __nedges     = nes }
    poke :: Ptr CTriangulation -> CTriangulation -> IO ()
poke Ptr CTriangulation
ptr (CTriangulation Ptr CVertex
r1 CSize
r2 Ptr CTriangle
r3 CSize
r4 Ptr CEdge
r5 CSize
r6)
      = do
        (\Ptr CTriangulation
hsc_ptr -> forall a b. Storable a => Ptr b -> Int -> a -> IO ()
pokeByteOff Ptr CTriangulation
hsc_ptr Int
0)   Ptr CTriangulation
ptr Ptr CVertex
r1
{-# LINE 134 "src/Geometry/HCDT/Triangulation.hsc" #-}
        (\Ptr CTriangulation
hsc_ptr -> forall a b. Storable a => Ptr b -> Int -> a -> IO ()
pokeByteOff Ptr CTriangulation
hsc_ptr Int
8)  Ptr CTriangulation
ptr CSize
r2
{-# LINE 135 "src/Geometry/HCDT/Triangulation.hsc" #-}
        (\Ptr CTriangulation
hsc_ptr -> forall a b. Storable a => Ptr b -> Int -> a -> IO ()
pokeByteOff Ptr CTriangulation
hsc_ptr Int
16)  Ptr CTriangulation
ptr Ptr CTriangle
r3
{-# LINE 136 "src/Geometry/HCDT/Triangulation.hsc" #-}
        (\Ptr CTriangulation
hsc_ptr -> forall a b. Storable a => Ptr b -> Int -> a -> IO ()
pokeByteOff Ptr CTriangulation
hsc_ptr Int
24) Ptr CTriangulation
ptr CSize
r4
{-# LINE 137 "src/Geometry/HCDT/Triangulation.hsc" #-}
        (\Ptr CTriangulation
hsc_ptr -> forall a b. Storable a => Ptr b -> Int -> a -> IO ()
pokeByteOff Ptr CTriangulation
hsc_ptr Int
32)      Ptr CTriangulation
ptr Ptr CEdge
r5
{-# LINE 138 "src/Geometry/HCDT/Triangulation.hsc" #-}
        (\Ptr CTriangulation
hsc_ptr -> forall a b. Storable a => Ptr b -> Int -> a -> IO ()
pokeByteOff Ptr CTriangulation
hsc_ptr Int
40)     Ptr CTriangulation
ptr CSize
r6
{-# LINE 139 "src/Geometry/HCDT/Triangulation.hsc" #-}

data CCTriangulation = CCTriangulation {
    CCTriangulation -> Ptr CVertex
__vertices'    :: Ptr CVertex
  , CCTriangulation -> CSize
__nvertices'   :: CSize
  , CCTriangulation -> Ptr CTriangle
__triangles'   :: Ptr CTriangle
  , CCTriangulation -> CSize
__ntriangles'  :: CSize
  , CCTriangulation -> Ptr CEdge
__edges'       :: Ptr CEdge
  , CCTriangulation -> CSize
__nedges'      :: CSize
  , CCTriangulation -> Ptr CEdge
__fixededges'  :: Ptr CEdge
  , CCTriangulation -> CSize
__nfixededges' :: CSize
}

instance Storable CCTriangulation where
    sizeOf :: CCTriangulation -> Int
sizeOf    CCTriangulation
__ = (Int
64)
{-# LINE 153 "src/Geometry/HCDT/Triangulation.hsc" #-}
    alignment __ = 8
{-# LINE 154 "src/Geometry/HCDT/Triangulation.hsc" #-}
    peek ptr = do
      vs   <- (\hsc_ptr -> peekByteOff hsc_ptr 0) ptr
{-# LINE 156 "src/Geometry/HCDT/Triangulation.hsc" #-}
      nvs  <- (\hsc_ptr -> peekByteOff hsc_ptr 8) ptr
{-# LINE 157 "src/Geometry/HCDT/Triangulation.hsc" #-}
      ts   <- (\hsc_ptr -> peekByteOff hsc_ptr 16) ptr
{-# LINE 158 "src/Geometry/HCDT/Triangulation.hsc" #-}
      nts  <- (\hsc_ptr -> peekByteOff hsc_ptr 24) ptr
{-# LINE 159 "src/Geometry/HCDT/Triangulation.hsc" #-}
      es   <- (\hsc_ptr -> peekByteOff hsc_ptr 32) ptr
{-# LINE 160 "src/Geometry/HCDT/Triangulation.hsc" #-}
      nes  <- (\hsc_ptr -> peekByteOff hsc_ptr 40) ptr
{-# LINE 161 "src/Geometry/HCDT/Triangulation.hsc" #-}
      fes  <- (\hsc_ptr -> peekByteOff hsc_ptr 48) ptr
{-# LINE 162 "src/Geometry/HCDT/Triangulation.hsc" #-}
      nfes <- (\hsc_ptr -> peekByteOff hsc_ptr 56) ptr
{-# LINE 163 "src/Geometry/HCDT/Triangulation.hsc" #-}
      return CCTriangulation { __vertices'    = vs
                            , __nvertices'   = nvs
                            , __triangles'   = ts
                            , __ntriangles'  = nts
                            , __edges'       = es
                            , __nedges'      = nes 
                            , __fixededges'  = fes
                            , __nfixededges' = nfes }
    poke :: Ptr CCTriangulation -> CCTriangulation -> IO ()
poke Ptr CCTriangulation
ptr (CCTriangulation Ptr CVertex
r1 CSize
r2 Ptr CTriangle
r3 CSize
r4 Ptr CEdge
r5 CSize
r6 Ptr CEdge
r7 CSize
r8)
      = do
        (\Ptr CCTriangulation
hsc_ptr -> forall a b. Storable a => Ptr b -> Int -> a -> IO ()
pokeByteOff Ptr CCTriangulation
hsc_ptr Int
0)    Ptr CCTriangulation
ptr Ptr CVertex
r1
{-# LINE 174 "src/Geometry/HCDT/Triangulation.hsc" #-}
        (\Ptr CCTriangulation
hsc_ptr -> forall a b. Storable a => Ptr b -> Int -> a -> IO ()
pokeByteOff Ptr CCTriangulation
hsc_ptr Int
8)   Ptr CCTriangulation
ptr CSize
r2
{-# LINE 175 "src/Geometry/HCDT/Triangulation.hsc" #-}
        (\Ptr CCTriangulation
hsc_ptr -> forall a b. Storable a => Ptr b -> Int -> a -> IO ()
pokeByteOff Ptr CCTriangulation
hsc_ptr Int
16)   Ptr CCTriangulation
ptr Ptr CTriangle
r3
{-# LINE 176 "src/Geometry/HCDT/Triangulation.hsc" #-}
        (\Ptr CCTriangulation
hsc_ptr -> forall a b. Storable a => Ptr b -> Int -> a -> IO ()
pokeByteOff Ptr CCTriangulation
hsc_ptr Int
24)  Ptr CCTriangulation
ptr CSize
r4
{-# LINE 177 "src/Geometry/HCDT/Triangulation.hsc" #-}
        (\Ptr CCTriangulation
hsc_ptr -> forall a b. Storable a => Ptr b -> Int -> a -> IO ()
pokeByteOff Ptr CCTriangulation
hsc_ptr Int
32)       Ptr CCTriangulation
ptr Ptr CEdge
r5
{-# LINE 178 "src/Geometry/HCDT/Triangulation.hsc" #-}
        (\Ptr CCTriangulation
hsc_ptr -> forall a b. Storable a => Ptr b -> Int -> a -> IO ()
pokeByteOff Ptr CCTriangulation
hsc_ptr Int
40)      Ptr CCTriangulation
ptr CSize
r6
{-# LINE 179 "src/Geometry/HCDT/Triangulation.hsc" #-}
        (\Ptr CCTriangulation
hsc_ptr -> forall a b. Storable a => Ptr b -> Int -> a -> IO ()
pokeByteOff Ptr CCTriangulation
hsc_ptr Int
48)  Ptr CCTriangulation
ptr Ptr CEdge
r7
{-# LINE 180 "src/Geometry/HCDT/Triangulation.hsc" #-}
        (\Ptr CCTriangulation
hsc_ptr -> forall a b. Storable a => Ptr b -> Int -> a -> IO ()
pokeByteOff Ptr CCTriangulation
hsc_ptr Int
56) Ptr CCTriangulation
ptr CSize
r8
{-# LINE 181 "src/Geometry/HCDT/Triangulation.hsc" #-}

cTriangulationToTriangulation :: CTriangulation -> IO Triangulation
cTriangulationToTriangulation :: CTriangulation -> IO Triangulation
cTriangulationToTriangulation CTriangulation
ctriangulation = do
  let nvertices :: Int
nvertices  = forall a b. (Integral a, Num b) => a -> b
fromIntegral forall a b. (a -> b) -> a -> b
$ CTriangulation -> CSize
__nvertices CTriangulation
ctriangulation
      ntriangles :: Int
ntriangles = forall a b. (Integral a, Num b) => a -> b
fromIntegral forall a b. (a -> b) -> a -> b
$ CTriangulation -> CSize
__ntriangles CTriangulation
ctriangulation
      nedges :: Int
nedges     = forall a b. (Integral a, Num b) => a -> b
fromIntegral forall a b. (a -> b) -> a -> b
$ CTriangulation -> CSize
__nedges CTriangulation
ctriangulation
  [CVertex]
vertices  <- forall a. Storable a => Int -> Ptr a -> IO [a]
peekArray Int
nvertices  (CTriangulation -> Ptr CVertex
__vertices CTriangulation
ctriangulation)
  [CTriangle]
triangles <- forall a. Storable a => Int -> Ptr a -> IO [a]
peekArray Int
ntriangles (CTriangulation -> Ptr CTriangle
__triangles CTriangulation
ctriangulation)
  [CEdge]
edges     <- forall a. Storable a => Int -> Ptr a -> IO [a]
peekArray Int
nedges     (CTriangulation -> Ptr CEdge
__edges CTriangulation
ctriangulation)
  [Vertex]
vertices'  <- forall (t :: * -> *) (m :: * -> *) a b.
(Traversable t, Monad m) =>
(a -> m b) -> t a -> m (t b)
mapM CVertex -> IO Vertex
cVertexToVertex [CVertex]
vertices
  [Triangle]
triangles' <- forall (t :: * -> *) (m :: * -> *) a b.
(Traversable t, Monad m) =>
(a -> m b) -> t a -> m (t b)
mapM CTriangle -> IO Triangle
cTriangleToTriangle [CTriangle]
triangles
  [Edge]
edges'     <- forall (t :: * -> *) (m :: * -> *) a b.
(Traversable t, Monad m) =>
(a -> m b) -> t a -> m (t b)
mapM CEdge -> IO Edge
cEdgeToEdge [CEdge]
edges
  forall (m :: * -> *) a. Monad m => a -> m a
return forall a b. (a -> b) -> a -> b
$ Triangulation { _vertices :: IntMap Vertex
_vertices  = forall a. [(Int, a)] -> IntMap a
IM.fromAscList (forall a b. [a] -> [b] -> [(a, b)]
zip [Int
0 .. Int
nverticesforall a. Num a => a -> a -> a
-Int
1] [Vertex]
vertices')
                         , _triangles :: [Triangle]
_triangles = [Triangle]
triangles'
                         , _edges :: [Edge]
_edges     = [Edge]
edges' }

cCTriangulationToConstrainedTriangulation :: CCTriangulation -> IO ConstrainedTriangulation
cCTriangulationToConstrainedTriangulation :: CCTriangulation -> IO ConstrainedTriangulation
cCTriangulationToConstrainedTriangulation CCTriangulation
cctriangulation = do
  let nvertices :: Int
nvertices  = forall a b. (Integral a, Num b) => a -> b
fromIntegral forall a b. (a -> b) -> a -> b
$ CCTriangulation -> CSize
__nvertices' CCTriangulation
cctriangulation
      ntriangles :: Int
ntriangles = forall a b. (Integral a, Num b) => a -> b
fromIntegral forall a b. (a -> b) -> a -> b
$ CCTriangulation -> CSize
__ntriangles' CCTriangulation
cctriangulation
      nedges :: Int
nedges     = forall a b. (Integral a, Num b) => a -> b
fromIntegral forall a b. (a -> b) -> a -> b
$ CCTriangulation -> CSize
__nedges' CCTriangulation
cctriangulation
      nfedges :: Int
nfedges    = forall a b. (Integral a, Num b) => a -> b
fromIntegral forall a b. (a -> b) -> a -> b
$ CCTriangulation -> CSize
__nfixededges' CCTriangulation
cctriangulation
  [CVertex]
vertices  <- forall a. Storable a => Int -> Ptr a -> IO [a]
peekArray Int
nvertices  (CCTriangulation -> Ptr CVertex
__vertices' CCTriangulation
cctriangulation)
  [CTriangle]
triangles <- forall a. Storable a => Int -> Ptr a -> IO [a]
peekArray Int
ntriangles (CCTriangulation -> Ptr CTriangle
__triangles' CCTriangulation
cctriangulation)
  [CEdge]
edges     <- forall a. Storable a => Int -> Ptr a -> IO [a]
peekArray Int
nedges     (CCTriangulation -> Ptr CEdge
__edges' CCTriangulation
cctriangulation)
  [CEdge]
fedges    <- forall a. Storable a => Int -> Ptr a -> IO [a]
peekArray Int
nfedges    (CCTriangulation -> Ptr CEdge
__fixededges' CCTriangulation
cctriangulation)
  [Vertex]
vertices'  <- forall (t :: * -> *) (m :: * -> *) a b.
(Traversable t, Monad m) =>
(a -> m b) -> t a -> m (t b)
mapM CVertex -> IO Vertex
cVertexToVertex [CVertex]
vertices
  [Triangle]
triangles' <- forall (t :: * -> *) (m :: * -> *) a b.
(Traversable t, Monad m) =>
(a -> m b) -> t a -> m (t b)
mapM CTriangle -> IO Triangle
cTriangleToTriangle [CTriangle]
triangles
  [Edge]
edges'     <- forall (t :: * -> *) (m :: * -> *) a b.
(Traversable t, Monad m) =>
(a -> m b) -> t a -> m (t b)
mapM CEdge -> IO Edge
cEdgeToEdge [CEdge]
edges
  [Edge]
fedges'    <- forall (t :: * -> *) (m :: * -> *) a b.
(Traversable t, Monad m) =>
(a -> m b) -> t a -> m (t b)
mapM CEdge -> IO Edge
cEdgeToEdge [CEdge]
fedges
  let triangulation :: Triangulation
triangulation = Triangulation { 
                          _vertices :: IntMap Vertex
_vertices  = forall a. [(Int, a)] -> IntMap a
IM.fromAscList (forall a b. [a] -> [b] -> [(a, b)]
zip [Int
0 .. Int
nverticesforall a. Num a => a -> a -> a
-Int
1] [Vertex]
vertices')
                        , _triangles :: [Triangle]
_triangles = [Triangle]
triangles'
                        , _edges :: [Edge]
_edges     = [Edge]
edges' 
                      }
  forall (m :: * -> *) a. Monad m => a -> m a
return ConstrainedTriangulation { 
                          _triangulation :: Triangulation
_triangulation = Triangulation
triangulation
                        , _fixedEdges :: [Edge]
_fixedEdges    = [Edge]
fedges' }

foreign import ccall unsafe "delaunay" c_delaunay
  :: Ptr CVertex -> CSize -> IO (Ptr CTriangulation)

foreign import ccall unsafe "cdelaunay" c_cdelaunay
  :: Ptr CVertex -> CSize -> Ptr CEdge -> CSize -> IO (Ptr CCTriangulation)