public bool Process (Segmentator s, Room r)
{
if(r.TypeOfRoom!=RoomType.Dining ||
r.TypeOfRoom!=RoomType.Kitchen)
return false;
List<LogicHob> hobs = new List<LogicHob>();
List<LogicSink> sinks = new List<LogicSink>();
foreach(ILogicObject l in r.LogicObjects)
{
if(l.ObjectType==CellObjects.Hob)
hobs.Add(l as LogicHob);
else if(l.ObjectType==CellObjects.Sink)
sinks.Add(l as LogicSink);
}
foreach(LogicHob hob in hobs)
{
foreach(LogicSink sink in sinks)
{
if(Vector3.Distance(sink.Center,hob.Center)<1.5f)
return true;
}
}
return false;
}
public bool Process (Segmentator s, Room r)
{
int totalPower = 0;
if(r.TypeOfRoom==RoomType.Coridor
|| r.TypeOfRoom==RoomType.Storage
|| r.TypeOfRoom==RoomType.Garage
|| r.TypeOfRoom==RoomType.Toilet)
return false;
foreach(ILogicObject o in r.LogicObjects)
{
if(o is LogicHeater)
{
LogicHeater heater = o as LogicHeater;
if(heater.Operates)
totalPower+=heater.Power;
}
if(o is LogicFireplace)
{
LogicFireplace fire = o as LogicFireplace;
totalPower+=fire.Power;
}
}
if(totalPower<r.LogicCells.Count)
return true;
return false;
}
public bool Process(Segmentator s, Room r)
{
int totalPower = 0;
if (r.TypeOfRoom == RoomType.Coridor ||
r.TypeOfRoom == RoomType.Storage ||
r.TypeOfRoom == RoomType.Garage ||
r.TypeOfRoom == RoomType.Toilet)
{
return(false);
}
foreach (ILogicObject o in r.LogicObjects)
{
if (o is LogicHeater)
{
LogicHeater heater = o as LogicHeater;
if (heater.Operates)
{
totalPower += heater.Power;
}
}
if (o is LogicFireplace)
{
LogicFireplace fire = o as LogicFireplace;
totalPower += fire.Power;
}
}
if (totalPower < r.LogicCells.Count)
{
return(true);
}
return(false);
}
protected override void Awake ()
{
base.Awake ();
segmentator = GetComponent<Segmentator>();
}
private void Sale()
{
M.Statistic.EquipmentCost = M.UI.bCostsPanel.Expences.Value;
Segmentator s = GetComponent <Segmentator>();
s.Launch(LevelConditions, cells, walls);
}
public bool Process (Segmentator s, ILogicObject o)
{
bool res = false;
if(o.ObjectType == CellObjects.Heater ||
o.ObjectType == CellObjects.HeatingPipe ||
o.ObjectType == CellObjects.Sink ||
o.ObjectType == CellObjects.Toilet)
return false;
o.ObjectRect.Foreach((MapPoint p) => {
WallPoint wp;
wp = new WallPoint(p.X,p.Y);
if(s.Doors.ContainsKey(wp.toInt()))
res = true;
wp = new WallPoint(p.X+1,p.Y);
if(s.Doors.ContainsKey(wp.toInt()))
res = true;
wp = new WallPoint(p.X,p.Y+1);
if(s.Doors.ContainsKey(wp.toInt()))
res = true;
wp = new WallPoint(p.X+1,p.Y+1);
if(s.Doors.ContainsKey(wp.toInt()))
res = true;
});
return res;
}
public bool Process (Segmentator s, Room r)
{
if(s.Conditions.FamilySize==2 && r.TypeOfRoom==RoomType.Studio)
return true;
return false;
}
public void TestWithAdequateMinutiaeSet()
{
int[,] mask = Segmentator.Segmetator(img, windowSize, weight, threshold);
double[,] binaryImage = img; //
//---------------------------------------
double sigma = 1.4d;
double[,] smoothing = LocalBinarizationCanny.Smoothing(binaryImage, sigma);
double[,] sobel = LocalBinarizationCanny.Sobel(smoothing);
double[,] nonMax = LocalBinarizationCanny.NonMaximumSupperession(sobel);
nonMax = GlobalBinarization.Binarization(nonMax, 60);
nonMax = LocalBinarizationCanny.Inv(nonMax);
int sizeWin = 16;
binaryImage = LocalBinarizationCanny.LocalBinarization(binaryImage, nonMax, sizeWin, 1.3d);
//---------------------------------------
binaryImage = Thining.ThinPicture(binaryImage);
//---------------------------------------
List <Minutia> minutiae = MinutiaeDetection.FindMinutiae(binaryImage);
for (int i = 0; i < minutiae.Count; i++)
{
if (mask[minutiae[i].Y, minutiae[i].X] == 0)
{
minutiae.Remove(minutiae[i]);
i--;
}
}
minutiae = MinutiaeDetection.FindBigMinutiae(minutiae);
var response = MCC.MCCMethod(minutiae, img.GetLength(0), img.GetLength(1));
SaveResponse(response, minutiae);
}
private void MessageArrivedSegmentedCallback(object sender, MqttMsgPublishEventArgs e)
{
if (Segmentator.Push(Array.ConvertAll(e.Message.ToString().Split(','), double.Parse)) == true)
{
OnReadFinished(Segmentator.Window);
}
}
public bool Process (Segmentator s, Room r)
{
if(r.TypeOfRoom==TypeOfRoom && r.Ventilated==false)
return true;
return false;
}
public bool Process (Segmentator s, Room r)
{
processed = new List<LogicCell>();
Dictionary<Door,LogicCell> doorCells = new Dictionary<Door, LogicCell>();
foreach(Door d in r.Doors)
{
if(doorCells.ContainsKey(d))
continue;
LogicCell c = null;
MapPoint p = null;
p =new MapPoint(d.Position.X,d.Position.Y);
if(r.LogicCells.TryGetValue(p.toInt(),out c) && !processed.Contains(c))
{
processed.Add(c);
doorCells.Add(d,c);
continue;
}
p =new MapPoint(d.Position.X-1,d.Position.Y);
if(r.LogicCells.TryGetValue(p.toInt(),out c) && !processed.Contains(c))
{
processed.Add(c);
doorCells.Add(d,c);
continue;
}
p =new MapPoint(d.Position.X,d.Position.Y-1);
if(r.LogicCells.TryGetValue(p.toInt(),out c) && !processed.Contains(c))
{
processed.Add(c);
doorCells.Add(d,c);
continue;
}
p =new MapPoint(d.Position.X-1,d.Position.Y-1);
if(r.LogicCells.TryGetValue(p.toInt(),out c) && !processed.Contains(c))
{
processed.Add(c);
doorCells.Add(d,c);
continue;
}
}
toProcess = new List<LogicCell>(doorCells.Values);
if(toProcess.Count==0)
return false;
processed.Clear();
Recursive(toProcess[0]);
if(toProcess.Count>0)
return true;
return false;
}
public void ExperimentMethod()
{
double[,] img1 = ImageHelper.LoadImage(Resources._104_6);
int[,] resultImg1;
resultImg1 = Segmentator.Segmetator(img1, windowSize, weight, threshold).Select2D(x => x > 0 ? 255 : 0);
ImageHelper.SaveIntArray(resultImg1, Path.GetTempPath() + "Segm_104_6" + ".png");
}
/*
public override string Name {
get {
return base.Name+": "+Enum.GetName(typeof(RoomType),TypeOfRoom);
}
}*/
#region IRoomRule implementation
public bool Process (Segmentator s, Room r)
{
if(r.TypeOfRoom==TypeOfRoom)
{
return !r.ContainsRectangle(sizeX,sizeY);
}
return false;
}
/*
* public override string Name {
* get {
* return base.Name+": "+Enum.GetName(typeof(RoomType),TypeOfRoom);
* }
* }*/
#region IRoomRule implementation
public bool Process(Segmentator s, Room r)
{
if (r.TypeOfRoom == TypeOfRoom)
{
return(!r.ContainsRectangle(sizeX, sizeY));
}
return(false);
}
public bool Process(Segmentator s, Room r)
{
if (r.TypeOfRoom == Room && !r.Contains(ObjectType))
{
return(true);
}
return(false);
}
public bool Process(Segmentator s, Room r)
{
return(r.TypeOfRoom == TypeOfRoom &&
((s.Conditions.SouthScenery == SceneryType.Park && r.SouthWindows) ||
(s.Conditions.NorthScenery == SceneryType.Park && r.NorthWindows) ||
(s.Conditions.EastScenery == SceneryType.Park && r.EastWindows) ||
(s.Conditions.WestScenery == SceneryType.Park && r.WestWindows)));
}
public bool Process(Segmentator s, Room r)
{
if (r.TypeOfRoom == TypeOfRoom && r.Ventilated == false)
{
return(true);
}
return(false);
}
public bool Process(Segmentator s, Room r)
{
if (s.Conditions.FamilySize == 2 && r.TypeOfRoom == RoomType.Studio)
{
return(true);
}
return(false);
}
/*public override string Name {
get {
return base.Name+": "+Enum.GetName(typeof(RoomType),TypeOfRoom);
}
}*/
#region IRoomRule implementation
public bool Process (Segmentator s, Room r)
{
if(r.TypeOfRoom==TypeOfRoom)
{
if(!r.SouthWindows && !r.NorthWindows && !r.EastWindows && !r.WestWindows)
return true;
}
return false;
}
public bool Process (Segmentator s, Room r)
{
return r.TypeOfRoom==TypeOfRoom &&
((s.Conditions.SouthScenery==SceneryType.Park && r.SouthWindows) ||
(s.Conditions.NorthScenery==SceneryType.Park && r.NorthWindows) ||
(s.Conditions.EastScenery==SceneryType.Park && r.EastWindows) ||
(s.Conditions.WestScenery==SceneryType.Park && r.WestWindows));
}
public bool Process (Segmentator s, Room r)
{
if(r.TypeOfRoom!=RoomType.Bathroom &&
r.TypeOfRoom!=RoomType.ToiletBathroom)
return false;
return r.Contains(CellObjects.Sink);
}
public bool Process (Segmentator s, ILogicObject o)
{
if(o is IHotWaterConsumer)
{
IHotWaterConsumer hot = o as IHotWaterConsumer;
if(!hot.HasHotWater)
return true;
}
return false;
}
public bool Process (Segmentator s)
{
foreach(Room room in s.Rooms)
{
foreach(RoomType rt in Rooms)
if(rt==room.TypeOfRoom)
return false;
}
return true;
}
public bool Process(Segmentator s, Room r)
{
if (r.TypeOfRoom != RoomType.Bathroom &&
r.TypeOfRoom != RoomType.ToiletBathroom)
{
return(false);
}
return(r.Contains(CellObjects.Sink));
}
/*public override string Name {
* get {
* return base.Name+": "+Enum.GetName(typeof(RoomType),TypeOfRoom);
* }
* }*/
#region IRoomRule implementation
public bool Process(Segmentator s, Room r)
{
if (r.TypeOfRoom == TypeOfRoom)
{
if (!r.SouthWindows && !r.NorthWindows && !r.EastWindows && !r.WestWindows)
{
return(true);
}
}
return(false);
}
public bool Process (Segmentator s)
{
int coridors = 0;
foreach(Room r in s.Rooms)
if(r.TypeOfRoom==RoomType.Coridor)
coridors+=r.LogicCells.Count;
float portion = (float)coridors / (float)s.LogicCells.Count;
return portion>=0.25f;
}
public bool Process(Segmentator s, ILogicObject o)
{
if (o is IHotWaterConsumer)
{
IHotWaterConsumer hot = o as IHotWaterConsumer;
if (!hot.HasHotWater)
{
return(true);
}
}
return(false);
}
public bool Process(Segmentator s)
{
foreach (Room room in s.Rooms)
{
foreach (RoomType rt in Rooms)
{
if (rt == room.TypeOfRoom)
{
return(false);
}
}
}
return(true);
}
public bool Process (Segmentator s)
{
int totalPower = 0;
foreach(LogicHeater h in s.LCache.Heaters)
{
if(h.Operates)
totalPower+=h.Power;
}
foreach(LogicFireplace f in s.LCache.Fireplaces)
totalPower+=f.Power;
if(totalPower<s.CellsCount)
return true;
return false;
}
public bool Process(Segmentator s)
{
int coridors = 0;
foreach (Room r in s.Rooms)
{
if (r.TypeOfRoom == RoomType.Coridor)
{
coridors += r.LogicCells.Count;
}
}
float portion = (float)coridors / (float)s.LogicCells.Count;
return(portion >= 0.25f);
}
public bool Process (Segmentator s, Room r)
{
if(r.TypeOfRoom!=RoomType.Bedroom)
return false;
int count = 0;
foreach(Room n in r.ConnectedTo)
{
if(n.TypeOfRoom!=RoomType.Toilet && n.TypeOfRoom!=RoomType.ToiletBathroom)
count++;
}
if(count>1)
return true;
return false;
}
public override void Start()
{
if (Segmentator == null)
{
OnReadFinished(Client.GetRecords <double[]>().ToList <double[]>());
}
else
{
while (Client.Read())
{
if (Segmentator.Push(Client.GetRecord <double[]>()) == true)
{
OnReadFinished(Segmentator.Window);
}
}
}
}
public bool Process (Segmentator s, Room r)
{
if(r.TypeOfRoom!=RoomType.Dining ||
r.TypeOfRoom!=RoomType.Kitchen)
return false;
List<LogicHob> hobs = r.GetObjects<LogicHob>();
foreach(LogicHob h in hobs)
{
MapPoint pos = new MapPoint(h.ObjectRect.MinX,h.ObjectRect.MinY);
LogicCell cell = r.LogicCells[pos.toInt()];
if(cell.ReachableCells.Count==4)
return true;
}
return false;
}
public void SegmentatorTest()
{
var image = Resources.SampleFinger;
Segmentator M = new Segmentator(image);
float [,] matrix = M.SobelFilter();
byte[,] byteMatrix = M.Segmentate();
string filename = "Result.jpg";
Bitmap bmp = M.MakeBitmap(byteMatrix);
M.SaveSegmentation(bmp, filename);
image.Dispose();
bmp.Dispose();
}
public void TestMcc()
{
int[,] maskOfSegmentation2D = Segmentator.Segmetator(img, windowSize, weight, threshold);
var thining = Thining.ThinPicture(GlobalBinarization.Binarization(img, board));
List <Minutia> minutiaList = MinutiaeDetection.FindMinutiae(thining);
List <Minutia> validMinutiae = new List <Minutia>();
foreach (Minutia minutia in minutiaList)
{
if (maskOfSegmentation2D[minutia.Y, minutia.X] == 1) // coordinates swap - ok
{
validMinutiae.Add(minutia);
}
}
var response = MCC.MCCMethod(validMinutiae, thining.GetLength(0), thining.GetLength(1));
SaveResponse(response, validMinutiae);
}
public bool Process(Segmentator s, ILogicObject o)
{
bool res = false;
if (o.ObjectType == CellObjects.Heater ||
o.ObjectType == CellObjects.HeatingPipe ||
o.ObjectType == CellObjects.Sink ||
o.ObjectType == CellObjects.Toilet)
{
return(false);
}
o.ObjectRect.Foreach((MapPoint p) => {
WallPoint wp;
wp = new WallPoint(p.X, p.Y);
if (s.Doors.ContainsKey(wp.toInt()))
{
res = true;
}
wp = new WallPoint(p.X + 1, p.Y);
if (s.Doors.ContainsKey(wp.toInt()))
{
res = true;
}
wp = new WallPoint(p.X, p.Y + 1);
if (s.Doors.ContainsKey(wp.toInt()))
{
res = true;
}
wp = new WallPoint(p.X + 1, p.Y + 1);
if (s.Doors.ContainsKey(wp.toInt()))
{
res = true;
}
});
return(res);
}
public bool Process(Segmentator s)
{
int totalPower = 0;
foreach (LogicHeater h in s.LCache.Heaters)
{
if (h.Operates)
{
totalPower += h.Power;
}
}
foreach (LogicFireplace f in s.LCache.Fireplaces)
{
totalPower += f.Power;
}
if (totalPower < s.CellsCount)
{
return(true);
}
return(false);
}
public bool Process(Segmentator s, Room r)
{
if (r.TypeOfRoom != RoomType.Dining ||
r.TypeOfRoom != RoomType.Kitchen)
{
return(false);
}
List <LogicHob> hobs = r.GetObjects <LogicHob>();
foreach (LogicHob h in hobs)
{
MapPoint pos = new MapPoint(h.ObjectRect.MinX, h.ObjectRect.MinY);
LogicCell cell = r.LogicCells[pos.toInt()];
if (cell.ReachableCells.Count == 4)
{
return(true);
}
}
return(false);
}
public bool Process(Segmentator s, Room r)
{
if (r.TypeOfRoom != RoomType.Bedroom)
{
return(false);
}
int count = 0;
foreach (Room n in r.ConnectedTo)
{
if (n.TypeOfRoom != RoomType.Toilet && n.TypeOfRoom != RoomType.ToiletBathroom)
{
count++;
}
}
if (count > 1)
{
return(true);
}
return(false);
}
public bool Process(Segmentator s, Room r)
{
if (r.TypeOfRoom != RoomType.Dining ||
r.TypeOfRoom != RoomType.Kitchen)
{
return(false);
}
List <LogicHob> hobs = new List <LogicHob>();
List <LogicSink> sinks = new List <LogicSink>();
foreach (ILogicObject l in r.LogicObjects)
{
if (l.ObjectType == CellObjects.Hob)
{
hobs.Add(l as LogicHob);
}
else if (l.ObjectType == CellObjects.Sink)
{
sinks.Add(l as LogicSink);
}
}
foreach (LogicHob hob in hobs)
{
foreach (LogicSink sink in sinks)
{
if (Vector3.Distance(sink.Center, hob.Center) < 1.5f)
{
return(true);
}
}
}
return(false);
}
public bool Process(Segmentator s)
{
return(s.LCache.BedroomsCount >= ((s.Conditions.FamilySize + 1) / 2));
}
protected override void Awake()
{
base.Awake();
segmentator = GetComponent <Segmentator>();
}
public bool Process (Segmentator s)
{
return s.LCache.ToiletsCount>=2 && s.Conditions.FamilySize>=4;
}
public bool Process (Segmentator s)
{
return s.LCache.Bathtubs.Count>0 && s.Conditions.FamilySize>=4;
}
public bool Process(Segmentator s)
{
return(s.LCache.Bathtubs.Count > 0 && s.Conditions.FamilySize >= 4);
}
public bool Process(Segmentator s, Room r)
{
return(r.TypeOfRoom == RoomType.Dining && s.Conditions.FamilySize >= 4);
}
public float[] SegmentImage(float[] image, int rows, int columns, out int[,] mask, bool useCuda = false)
{
if (useCuda)
{
var maskRows = (int)Math.Ceiling((double)rows / Constants.SegmentationWindowSize);
var maskColumns = (int)Math.Ceiling((double)columns / Constants.SegmentationWindowSize);
var maskLinearized = new int[maskRows * maskColumns];
var sw = new Stopwatch();
sw.Start();
CUDASegmentator(image, columns, rows,
(float)Constants.SegmentationWeight, Constants.SegmentationWindowSize, maskLinearized, maskColumns, maskRows);
sw.Stop();
mask = maskLinearized.Make2D(maskRows, maskColumns);
Segmentator.PostProcessing(mask, Constants.SegmentationThreshold);
var bigMask = Segmentator.GetBigMask(mask, rows, columns,
Constants.SegmentationWindowSize);
// we discard border regions in order to not catch minutiae there
var oldMask = mask;
mask = oldMask.Select2D((x, row, column) =>
{
if (x == 0)
{
return(0);
}
if (row > 0)
{
if (oldMask[row - 1, column] == 0)
{
return(0);
}
if (column > 0)
{
if (oldMask[row - 1, column - 1] == 0)
{
return(0);
}
}
if (column < maskColumns - 1)
{
if (oldMask[row - 1, column + 1] == 0)
{
return(0);
}
}
if (row < maskRows - 1)
{
if (oldMask[row + 1, column] == 0)
{
return(0);
}
if (column > 0)
{
if (oldMask[row + 1, column - 1] == 0)
{
return(0);
}
}
if (column < maskColumns - 1)
{
if (oldMask[row + 1, column + 1] == 0)
{
return(0);
}
}
}
}
if (column > 0)
{
if (oldMask[row, column - 1] == 0)
{
return(0);
}
}
if (column < maskColumns - 1)
{
if (oldMask[row, column + 1] == 0)
{
return(0);
}
}
return(1);
});
return(Segmentator.ColorImage(image, rows, columns, bigMask));
}
mask = Segmentator.Segmetator(image.Make2D(rows, columns).Select2D(x => (double)x),
Constants.SegmentationWindowSize, Constants.SegmentationWeight,
Constants.SegmentationThreshold);
return(Segmentator.ColorImage(image.Make2D(rows, columns).Select2D(x => (double)x),
Segmentator.GetBigMask(mask, image.GetLength(0), image.GetLength(1),
Constants.SegmentationWindowSize)).Make1D().Select(x => (float)x).ToArray());
}
public Room(Segmentator s)
{
Seg = s;
}
public bool Process (Segmentator s, Room r)
{
return r.TypeOfRoom==RoomType.Dining && s.Conditions.FamilySize>=4;
}
public bool Process (Segmentator s)
{
return s.LCache.BedroomsCount>=((s.Conditions.FamilySize+1)/2);
}
public bool Process (Segmentator s, Room r)
{
return false;
}
public bool Process (Segmentator s, Room r)
{
return r.Contains(CellObjects.Ventshaft) || r.Contains(CellObjects.Riser);
}
public bool Process (Segmentator s, Room r)
{
if(r.TypeOfRoom==Room && !r.Contains(ObjectType))
return true;
return false;
}
public void OnProcessed(Segmentator s, Evaluator e)
{
state = Modes.Verify;
UI.OnShowVerify();
UI.OnShowWait(false);
}
