@startuml classdiagramSmarthies

' ////////////////////////////////////////////
' //			 Classes Mère 				//
' ////////////////////////////////////////////
class ProcessImageEngine{
	- Image * mOriginal
	- vector <Image *> vectProcessImage
	- vector <Image *> vectBackImage
	- LightCard * mLightCard
	- vector <UnyProc *> mUnyProc
	- vector <MultiProc *> mMultiProc
	+ void insertNewImage()
	+ void insertNewBackground()
	+ void creationLightCard()
	+ void processImage()
	+ void findResult()

}

class GUEngine{
	- ProcessImageEngine mProcessEngine
	+ void showImage()
	+ void showResult()
	+ void setup()
	+ void reset()
	+ void quit()
}
' ////////////	Fin des classes Mère

' ///////////////////////////////////////////
' // Classes pour l'évaluation d'une image //
' ///////////////////////////////////////////

abstract class UnyProc{
}

' Classe du Filtre d'image, ainsi que ces enfants
abstract class ImageFilter {
}

class Median{
	- int sizeFilter
	+ void performMed(Image & image)
}

class MaximumFilter{
	- int sizeFilter
	+ void maxFilter( vector<Image *> & vectImage)
}

class Convolution{
	# int sizeCore
	# <<virtual>> void performConv(Image & image)
}

class ConvolutionNormal{
	+ <<override>> void performConv(Image & image)
}
class ConvolutionGaussian{
	+ <<override>> void performConv(Image & image)
}

' Fin

class Uniformisation{
	- LightCard * ptrLightCard
	+ void performUni(Image * image)
}

class Normalisation{
	- int minValue
	- int MaxValue
 	+ void performNorm(Image & image)
}

class Segmentation {
	+ void performSeg(Image & image)
}

class FillingAreas{
	BlobExtractor mBlobExtractor
	# <<virtual>> void processLabeling(Image & image)
	+ perfomFilling(Image & image)
	+ void colorFlip(Image & image)
}

class BlobExtractor{
	- size_t mHeight{};
	- size_t mWidth{};
	- uint64_t deadPixel{};
	- uint64_t currentLabel{1};

	+ <<override>> void processLabeling(Image & image)
	- void deadBorder()
	- void parkourImage()
	- void pixelIdentificator(size_t x, size_t y)
	- void pixelIdentificator(size_t x, size_t y, uint64_t value);
	- void blobNeighboor(size_t x1, size_t y1, size_t x2, size_t y2);
	- void facadePixelCounter(size_t x, size_t y, uint64_t labelNumber);
	- void addDataBlob(size_t x, size_t y, uint64_t label);
	- void sortDataBlob();
	- bool compareDataBlob(Blob const &objInfo1, Blob const &objInfo2);

}

' Classe de Calcul des descripteurs, ainsi que ces enfants
class DescriptorCalculation {
	+ CalcComplexity * mComplexity;
	+ CalcArea * mArea;
	+ CalcPerimeter * mPerimeter;
}

class CalcComplexity {
	+ void calculationComp ()
}

class CalcArea {
	+ void calculationArea ()
}

class CalcPerimeter {
	+ void calculationPerim ()
}
' Fin

class ModifColor{
	+ RGBHSV * mRgbHsv
	+ HSVRGB * mHsvRgb
}

class RGBHSV{
	+ void change(Image & image)
}

class HSVRGB{
	+ void change(Image & image)
}

class Classification{
	+ void sortData()
}
' ////////////	Fin des classes pour l'évaluation d'une image


' //////////////////////////////////////////////////////
' // Classes pour l'évaluation de la carte d'éclairage//
' //////////////////////////////////////////////////////
abstract class MultiProc{

}

class AverageImage{
	+ void calculAvg( vector<Image *>*vectImage)
}

' ////////////	Fin des classes pour l'évaluation de la carte d'éclairage

' /////////////////////////////////////
' // Classes de la carte d'éclairage //
' /////////////////////////////////////
class LightCard << (S,#FF7700) Singleton >>{
	- Image m_LightCard
}
' ////////////	Fin des classes de la carte d'éclairage

' ////////////////////////////////////
' // Classes d'instance de la caméra//
' ////////////////////////////////////
class Camera << (S,#FF7700) Singleton >>{
	# <<virtual>> Image grab()
}

class Logitech{
	+ <<override>> Image grab()
	+ void connection ()
	+ void disconnection()

}

class DocCam{
	+ <<override>> Image grab()
}
' ////////////	Fin des classes d'instance de la caméra


' /////////////////////////////////
' // Classes et template d'image //
' /////////////////////////////////
class Image <  t  >{
}

class "Image< int >" as Image_int{
}

class "Image< float >" as Image_float{
	- vector <Blob *> vectBolb
}
' ////////////	Fin des classes et template d'image


' ///////////////////////////////////////////
' // Classes de l'idnttification des blobs //
' ///////////////////////////////////////////

class Blob{
	- int mLabel
	- int mFirstX
	- int mFirstY
	- float mComplexity
	- float mArea
	- float mPerimeter
}

' ////////////	Fin des classes de l'idnttification des blobs


Convolution "1"<|--"1" ConvolutionNormal
Convolution "1"<|--"1" ConvolutionGaussian

ImageFilter "1"<|--"1" Median
ImageFilter "1"<|--"1" MaximumFilter
ImageFilter "1"<|--"1" Convolution

FillingAreas "1"<|--"1" BlobExtractor

DescriptorCalculation "1"<|--"1" CalcComplexity
DescriptorCalculation "1"<|--"1" CalcArea
DescriptorCalculation "1"<|--"1" CalcPerimeter

ModifColor "1"<|--"1" RGBHSV
ModifColor "1"<|--"1" HSVRGB

UnyProc "1"<|--"*" ImageFilter
UnyProc "1"<|--"1" Uniformisation
UnyProc "1"<|--"1" Normalisation
UnyProc "1"<|--"1" Segmentation
UnyProc "1"<|--"1" FillingAreas
UnyProc "1"<|--"1" DescriptorCalculation
UnyProc "1"<|--"1" Classification
UnyProc "1"<|--"1" ModifColor

MultiProc "1"<|--"1" AverageImage

Camera "1"<|--"1" Logitech
Camera "1"<|--"1" DocCam

Image <|.. Image_int : "<<bind>>\n t = int"
Image <|.. Image_float : "<<bind>>\n t = float"

Image_float <|-- Blob

ProcessImageEngine "1"*--"*" UnyProc
ProcessImageEngine "1"*--"*" MultiProc
ProcessImageEngine "1"*--"1" Camera
ProcessImageEngine "1"*--"*" Image
ProcessImageEngine "1" *--"1" LightCard

GUEngine "1"*--"*" ProcessImageEngine

@enduml