{-# LANGUAGE InstanceSigs #-}
module Geometry.Qhull.Types
  where
import           Data.Hashable              ( Hashable(hashWithSalt) )
import           Data.HashMap.Strict.InsOrd ( InsOrdHashMap )
import           Data.IntMap.Strict         ( IntMap )
import           Data.IntSet                ( IntSet )

type Index = Int
type IndexMap = IntMap
type IndexSet = IntSet

data IndexPair = Pair Index Index
  deriving (Int -> IndexPair -> ShowS
[IndexPair] -> ShowS
IndexPair -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [IndexPair] -> ShowS
$cshowList :: [IndexPair] -> ShowS
show :: IndexPair -> String
$cshow :: IndexPair -> String
showsPrec :: Int -> IndexPair -> ShowS
$cshowsPrec :: Int -> IndexPair -> ShowS
Show, ReadPrec [IndexPair]
ReadPrec IndexPair
Int -> ReadS IndexPair
ReadS [IndexPair]
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [IndexPair]
$creadListPrec :: ReadPrec [IndexPair]
readPrec :: ReadPrec IndexPair
$creadPrec :: ReadPrec IndexPair
readList :: ReadS [IndexPair]
$creadList :: ReadS [IndexPair]
readsPrec :: Int -> ReadS IndexPair
$creadsPrec :: Int -> ReadS IndexPair
Read)
instance Eq IndexPair where
    (==) :: IndexPair -> IndexPair -> Bool
    Pair Int
i Int
j == :: IndexPair -> IndexPair -> Bool
== Pair Int
i' Int
j' = (Int
i forall a. Eq a => a -> a -> Bool
== Int
i' Bool -> Bool -> Bool
&& Int
j forall a. Eq a => a -> a -> Bool
== Int
j') Bool -> Bool -> Bool
|| (Int
i forall a. Eq a => a -> a -> Bool
== Int
j' Bool -> Bool -> Bool
&& Int
j forall a. Eq a => a -> a -> Bool
== Int
i')

instance Hashable IndexPair where
  hashWithSalt :: Int -> IndexPair -> Int
  hashWithSalt :: Int -> IndexPair -> Int
hashWithSalt Int
_ (Pair Int
i Int
j) = (Int
iforall a. Num a => a -> a -> a
+Int
j)forall a. Num a => a -> a -> a
*(Int
iforall a. Num a => a -> a -> a
+Int
jforall a. Num a => a -> a -> a
+Int
1) forall a. Num a => a -> a -> a
+ Int
2 forall a. Num a => a -> a -> a
* forall a. Ord a => a -> a -> a
min Int
i Int
j

type EdgeMap = InsOrdHashMap IndexPair ([Double],[Double])

data Family = Family Int | None
     deriving (Int -> Family -> ShowS
[Family] -> ShowS
Family -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [Family] -> ShowS
$cshowList :: [Family] -> ShowS
show :: Family -> String
$cshow :: Family -> String
showsPrec :: Int -> Family -> ShowS
$cshowsPrec :: Int -> Family -> ShowS
Show, ReadPrec [Family]
ReadPrec Family
Int -> ReadS Family
ReadS [Family]
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [Family]
$creadListPrec :: ReadPrec [Family]
readPrec :: ReadPrec Family
$creadPrec :: ReadPrec Family
readList :: ReadS [Family]
$creadList :: ReadS [Family]
readsPrec :: Int -> ReadS Family
$creadsPrec :: Int -> ReadS Family
Read, Family -> Family -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: Family -> Family -> Bool
$c/= :: Family -> Family -> Bool
== :: Family -> Family -> Bool
$c== :: Family -> Family -> Bool
Eq)

class HasFamily m where
  _family :: m -> Family

class HasNormal m where
  _normal :: m -> [Double]
  _offset :: m -> Double

class HasVertices m where
  _vertices :: m -> IndexMap [Double]

class HasEdges m where
  _edges :: m -> EdgeMap

class HasVolume m where
  _volume :: m -> Double

class HasCenter m where
  _center :: m -> [Double]