/***************************************************/
/**** Public Methods ****/
/***************************************************/
public static List <Tuple <LocalData <T>, LocalData <T> > > RelatedPairs <T>(this PointMatrix <T> matrix, double minDist, double maxDist)
{
int range = (int)Math.Ceiling(maxDist / matrix.CellSize);
double minSqrDist = minDist * minDist;
double maxSqrDist = maxDist * maxDist;
List <Tuple <LocalData <T>, LocalData <T> > > result = new List <Tuple <LocalData <T>, LocalData <T> > >();
foreach (KeyValuePair <DiscretePoint, List <LocalData <T> > > kvp in matrix.Data)
{
DiscretePoint k = kvp.Key;
List <LocalData <T> > closePoints = matrix.SubMatrixData <T>(
new DiscretePoint {
X = k.X - range, Y = k.Y - range, Z = k.Z - range
},
new DiscretePoint {
X = k.X + range, Y = k.Y + range, Z = k.Z + range
});
foreach (LocalData <T> value in kvp.Value)
{
foreach (LocalData <T> other in closePoints)
{
double sqrDist = value.Position.PMSquareDistance(other.Position);
if (sqrDist < maxSqrDist && sqrDist > minSqrDist)
{
result.Add(new Tuple <LocalData <T>, LocalData <T> >(value, other));
}
}
}
}
return(result);
}
/***************************************************/
/**** Public Methods ****/
/***************************************************/
public static List <LocalData <T> > SubMatrixData <T>(this PointMatrix <T> matrix, DiscretePoint minCell, DiscretePoint maxCell)
{
Dictionary <DiscretePoint, List <LocalData <T> > > data = matrix.Data;
List <LocalData <T> > inCells = new List <LocalData <T> >();
for (int x = minCell.X; x <= maxCell.X; x++)
{
for (int y = minCell.Y; y <= maxCell.Y; y++)
{
for (int z = minCell.Z; z <= maxCell.Z; z++)
{
DiscretePoint key = new DiscretePoint {
X = x, Y = y, Z = z
};
if (data.ContainsKey(key))
{
foreach (LocalData <T> comp in data[key])
{
inCells.Add(comp);
}
}
}
}
}
return(inCells);
}
public DiscretePoint ProccessDigital(DiscretePoint point)
{
point.TimeStamp = DateTime.Now.ToString();
var newPoint = ProccessDigitalAlarm(point);
return(newPoint);
}
public void Solution(string input, int n)
{
var arr = new char[n, n];
DiscretePoint bot = null;
DiscretePoint princess = null;
for (int i = 0; i < n; i++)
{
for (int j = 0; j < n; j++)
{
arr[i, j] = input[i * n + j];
if (arr[i, j] == 'm')
{
bot = new DiscretePoint(j, i);
}
if (arr[i, j] == 'p')
{
princess = new DiscretePoint(j, i);
}
}
}
DisplayPathtoPrincess(n, arr, bot, princess);
}
protected virtual char[,] RestrictView(char[,] source, DiscretePoint bot, bool restrict)
{
if (!restrict)
{
return(source);
}
char[,] grid = new char[source.GetLength(0), source.GetLength(1)];
for (int i = 0; i < grid.GetLength(0); i++)
{
for (int j = 0; j < grid.GetLength(1); j++)
{
grid[i, j] = 'o';
}
}
for (int i = -1; i <= 1; i++)
{
for (int j = -1; j <= 1; j++)
{
CheckAndCopy(source, grid, bot.Y + i, bot.X + j);
}
}
return(grid);
}
private static Dictionary <Tuple <RegisterType, int>, BasePoint> GetScadaModel(bool test = false)
{
var dict = new Dictionary <Tuple <RegisterType, int>, BasePoint>();
if (!test)
{
var analog = new AnalogPoint()
{
Alarm = AlarmType.NO_ALARM, ClassType = ClassType.CLASS_0, Direction = FTN.Common.SignalDirection.ReadWrite, Index = 1, MeasurementType = FTN.Common.MeasurementType.ActiveEnergy, Mrid = "TEST_ANALOG", ObjectMrid = null, RegisterType = RegisterType.ANALOG_OUTPUT, TimeStamp = DateTime.Now.ToString(), MaxValue = 5, MinValue = 0, NormalValue = 0, Value = 10
};
var binary = new DiscretePoint()
{
Alarm = AlarmType.NO_ALARM, ClassType = ClassType.CLASS_0, Direction = FTN.Common.SignalDirection.ReadWrite, Index = 3, MeasurementType = FTN.Common.MeasurementType.Status, Mrid = "TEST_BINARY", ObjectMrid = null, RegisterType = RegisterType.BINARY_OUTPUT, TimeStamp = DateTime.Now.ToString(), MaxValue = 1, MinValue = 0, NormalValue = 0, Value = 1
};
dict[Tuple.Create(analog.RegisterType, analog.Index)] = analog;
dict[Tuple.Create(binary.RegisterType, binary.Index)] = binary;
}
else
{
var analog = new AnalogPoint()
{
Alarm = AlarmType.NO_ALARM, ClassType = ClassType.CLASS_0, Direction = FTN.Common.SignalDirection.ReadWrite, Index = 1, MeasurementType = FTN.Common.MeasurementType.ActiveEnergy, Mrid = "TEST_ANALOG", ObjectMrid = null, RegisterType = RegisterType.ANALOG_OUTPUT, TimeStamp = DateTime.Now.ToString(), MaxValue = 7, MinValue = 0, NormalValue = 0, Value = 7
};
var binary = new DiscretePoint()
{
Alarm = AlarmType.NO_ALARM, ClassType = ClassType.CLASS_0, Direction = FTN.Common.SignalDirection.ReadWrite, Index = 3, MeasurementType = FTN.Common.MeasurementType.Status, Mrid = "TEST_BINARY", ObjectMrid = null, RegisterType = RegisterType.BINARY_OUTPUT, TimeStamp = DateTime.Now.ToString(), MaxValue = 1, MinValue = 0, NormalValue = 0, Value = 0
};
dict[Tuple.Create(analog.RegisterType, analog.Index)] = analog;
dict[Tuple.Create(binary.RegisterType, binary.Index)] = binary;
}
return(dict);
}
public void Solution(string input, int n, int x, int y)
{
var arr = GenerateGrid(input, n, n);
var bot = new DiscretePoint(x, y);
Solve(arr, bot);
}
private void ParseBinaryObject(byte[] binaryObject, ushort typeField, ref Dictionary <Tuple <RegisterType, int>, BasePoint> points)
{
RegisterType registerType = typeField == (ushort)TypeField.BINARY_INPUT_PACKED_FORMAT ? RegisterType.BINARY_INPUT : RegisterType.BINARY_OUTPUT;
int currentIndex = binaryObject[3];
for (int i = 5; i < binaryObject.Length; i++)
{
byte currentByte = binaryObject[i];
byte mask = 0x01;
for (int j = 0; j < 8; j++)
{
DiscretePoint point = new DiscretePoint();
point.Value = currentByte & mask;
point.Index = currentIndex;
point.RegisterType = registerType;
currentByte >>= 1;
points.Add(new Tuple <RegisterType, int>(registerType, currentIndex++), point);
if (currentIndex > binaryObject[4])
{
break;
}
}
}
}
public void ProccessDigitalAlarm(DiscretePoint point)
{
if (point.Value != point.NormalValue)
{
point.Alarm = AlarmType.ABNORMAL_VALUE;
}
else
{
point.Alarm = AlarmType.NO_ALARM;
}
}
/***************************************/
public static void Add <T>(this PointMatrix <T> matrix, Point position, T data = default(T))
{
Dictionary <DiscretePoint, List <LocalData <T> > > cells = matrix.Data;
DiscretePoint key = Create.DiscretePoint(position, matrix.CellSize);
if (!cells.ContainsKey(key))
{
cells[key] = new List <LocalData <T> >();
}
cells[key].Add(new LocalData <T> {
Position = position, Data = data
});
}
public Dictionary <Tuple <RegisterType, int>, BasePoint> Convert(List <PointDbModel> result)
{
var dict = new Dictionary <Tuple <RegisterType, int>, BasePoint>();
foreach (var item in result)
{
if (item.RegisterType == RegisterType.ANALOG_INPUT || item.RegisterType == RegisterType.ANALOG_OUTPUT)
{
var point = new AnalogPoint()
{
Alarm = item.Alarm,
ClassType = item.ClassType,
Direction = item.Direction,
Index = item.Index,
MaxValue = item.MaxValue,
MeasurementType = item.MeasurementType,
MinValue = item.MinValue,
NormalValue = item.NormalValue,
Mrid = item.Mrid,
ObjectMrid = item.ObjectMrid,
RegisterType = item.RegisterType,
TimeStamp = item.TimeStamp,
Value = item.Value
};
dict.Add(Tuple.Create(point.RegisterType, point.Index), point);
}
else
{
var point = new DiscretePoint()
{
Alarm = item.Alarm,
ClassType = item.ClassType,
Direction = item.Direction,
Index = item.Index,
MaxValue = (int)item.MaxValue,
MeasurementType = item.MeasurementType,
MinValue = (int)item.MinValue,
NormalValue = (int)item.NormalValue,
Mrid = item.Mrid,
ObjectMrid = item.ObjectMrid,
RegisterType = item.RegisterType,
TimeStamp = item.TimeStamp,
Value = (int)item.Value
};
dict.Add(Tuple.Create(point.RegisterType, point.Index), point);
}
}
return(dict);
}
public override string NextStep(char[,] grid, DiscretePoint bot)
{
// check if file exists
if (!this.CheckIfFileExists())
{
SaveFile(grid);
}
var cleangrid = this.ReadFile();
for (int i = -1; i <= 1; i++)
{
for (int j = -1; j <= 1; j++)
{
CheckAndCopy(grid, cleangrid, bot.Y + i, bot.X + j);
}
}
SaveFile(cleangrid);
DiscretePoint dirty = null;
dirty = FindNextClosestDirty(cleangrid, bot);
Directions dir;
if (dirty != null)
{
dir = GridUtils.GetBotDirection(bot, dirty);
if (dir != Directions.Stop)
{
return(dir.ToString().ToUpper());
}
else
{
return("CLEAN");
}
}
else
{
var hidden = FindFurthestHidden(cleangrid, bot);
if (hidden != null)
{
dir = GridUtils.GetBotDirection(bot, hidden);
return(dir.ToString().ToUpper());
}
}
return(null);
}
public void Solve(char[,] grid, DiscretePoint bot, bool restrict = false, int maxSteps = 100)
{
int steps = 0;
while (!CheckIfSolved(grid, bot) && steps <= maxSteps)
{
var restrictView = this.RestrictView(grid, bot, restrict);
PrintMaze(restrictView, bot);
var cmd = NextStep(restrictView, bot);
Log.Info(cmd);
ChangeEnv(grid, bot, cmd);
steps++;
}
}
public override bool CheckIfSolved(char[,] grid, DiscretePoint bot)
{
for (int i = 0; i < grid.GetLength(0); i++)
{
for (int j = 0; j < grid.GetLength(1); j++)
{
if (grid[i, j] == 'd')
{
return(false);
}
}
}
return(true);
}
public virtual void ChangeEnv(char[,] grid, DiscretePoint bot, string command)
{
Directions dir;
if (Enum.TryParse(command, true, out dir))
{
bot.Move(dir);
}
if (command == "CLEAN")
{
if (grid[bot.Y, bot.X] == 'd')
{
grid[bot.Y, bot.X] = '-';
}
}
}
/***************************************************/
public static PointMatrix <T> PointMatrix <T>(List <LocalData <T> > data, double cellSize = 1.0)
{
PointMatrix <T> matrix = new PointMatrix <T> {
CellSize = cellSize
};
Dictionary <DiscretePoint, List <LocalData <T> > > cells = matrix.Data;
foreach (LocalData <T> d in data)
{
DiscretePoint key = Create.DiscretePoint(d.Position, cellSize);
if (!cells.ContainsKey(key))
{
cells[key] = new List <LocalData <T> >();
}
cells[key].Add(d);
}
return(matrix);
}
protected override char[,] RestrictView(char[,] source, DiscretePoint bot, bool restrict)
{
if (!restrict)
{
return(source);
}
char[,] grid = new char[3, 3];
for (int i = -1; i <= 1; i++)
{
for (int j = -1; j <= 1; j++)
{
CheckAndCopy(source, grid, bot.Y + i, bot.X + j);
}
}
return(grid);
}
private void PrintMaze(char[,] grid, DiscretePoint bot)
{
for (int i = 0; i < grid.GetLength(0); i++)
{
string s = "";
for (int j = 0; j < grid.GetLength(1); j++)
{
if (i == bot.Y && j == bot.X)
{
s += 'b';
}
else
{
s += grid[i, j];
}
}
Log.Info(s);
}
}
static void DisplayPathtoPrincess(int n, char[,] grid, DiscretePoint bot, DiscretePoint princess)
{
List <Directions> directionses = new List <Directions>();
Directions dir;
do
{
dir = GridUtils.GetBotDirection(bot, princess);
if (dir != Directions.Stop)
{
directionses.Add(dir);
}
bot.Move(dir);
}while (dir != Directions.Stop);
foreach (var directionse in directionses)
{
Console.WriteLine(directionse.ToString().ToUpper());
}
}
public override string NextStep(char[,] grid, DiscretePoint bot)
{
DiscretePoint dirty = null;
dirty = FindNextClosestDirty(grid, bot);
if (dirty != null)
{
var dir = GridUtils.GetBotDirection(bot, dirty);
if (dir != Directions.Stop)
{
return(dir.ToString().ToUpper());
}
else
{
return("CLEAN");
}
}
return(null);
}
public override Dictionary <Tuple <RegisterType, int>, BasePoint> PareseResponse(byte[] response)
{
if (!CrcCalculator.CheckCRC(response))
{
return(null);
}
byte[] dataObjects = MessagesHelper.GetResponseDataObjects(response);
Dictionary <Tuple <RegisterType, int>, BasePoint> retVal = new Dictionary <Tuple <RegisterType, int>, BasePoint>();
DiscretePoint point = new DiscretePoint();
point.Index = (ushort)BitConverter.ToUInt16(dataObjects, 5);
byte controlCode = dataObjects[7];
point.Value = controlCode == 0x81 ? 0 : 1;
retVal.Add(new Tuple <RegisterType, int>(RegisterType.BINARY_OUTPUT, point.Index), point);
return(retVal);
}
static DiscretePoint FindFurthestHidden(char[,] grid, DiscretePoint bot)
{
DiscretePoint dirty = null;
double max = 0;
for (int i = 0; i < grid.GetLength(0); i++)
{
for (int j = 0; j < grid.GetLength(1); j++)
{
if (grid[i, j] == 'o')
{
var distance = GridUtils.Distance(bot.X, bot.Y, j, i);
if (distance > max)
{
max = distance;
dirty = new DiscretePoint(j, i);
}
}
}
}
return(dirty);
}
static DiscretePoint FindNextClosestDirty(char[,] grid, DiscretePoint bot)
{
DiscretePoint dirty = null;
double min = double.MaxValue;
for (int i = 0; i < grid.GetLength(0); i++)
{
for (int j = 0; j < grid.GetLength(1); j++)
{
if (grid[i, j] == 'd')
{
var distance = GridUtils.Distance(bot.X, bot.Y, j, i);
if (distance < min)
{
min = distance;
dirty = new DiscretePoint(j, i);
}
}
}
}
return(dirty);
}
private Dictionary <Tuple <RegisterType, int>, BasePoint> ConvertPoints(Container analogContainer, Container discreteContainer)
{
Dictionary <Tuple <RegisterType, int>, BasePoint> points = new Dictionary <Tuple <RegisterType, int>, BasePoint>();
foreach (var item in analogContainer.Entities.Values)
{
if (item is Analog)
{
Analog analog = item as Analog;
AnalogPoint analogPoint = new AnalogPoint()
{
ClassType = ClassType.CLASS_1,
Direction = analog.Direction,
RegisterType = GetRegistryType(analog.Direction),
Index = GetIndex(GetRegistryType(analog.Direction)),
MaxValue = analog.MaxValue,
MinValue = analog.MinValue,
MeasurementType = analog.MeasurementType,
Mrid = analog.MRID,
NormalValue = analog.NormalValue,
ObjectMrid = analog.ObjectMRID ?? null,
TimeStamp = String.Empty,
Value = 0,
Alarm = AlarmType.NO_ALARM
};
points.Add(new Tuple <RegisterType, int>(analogPoint.RegisterType, analogPoint.Index), analogPoint);
}
}
foreach (var item in discreteContainer.Entities.Values)
{
if (item is Discrete)
{
Discrete discrete = item as Discrete;
if (discrete.MRID.Contains("Discrete_Tap"))
{
AnalogPoint discretePoint = new AnalogPoint()
{
ClassType = ClassType.CLASS_2,
Direction = discrete.Direction,
RegisterType = RegisterType.ANALOG_OUTPUT,
Index = GetIndex(RegisterType.ANALOG_OUTPUT),
MaxValue = discrete.MaxValue,
MinValue = discrete.MinValue,
MeasurementType = discrete.MeasurementType,
Mrid = discrete.MRID,
NormalValue = discrete.NormalValue,
ObjectMrid = discrete.ObjectMRID ?? null,
TimeStamp = String.Empty,
Value = discrete.NormalValue,
Alarm = AlarmType.NO_ALARM
};
points.Add(new Tuple <RegisterType, int>(discretePoint.RegisterType, discretePoint.Index), discretePoint);
}
else
{
DiscretePoint discretePoint = new DiscretePoint()
{
ClassType = ClassType.CLASS_2,
Direction = discrete.Direction,
RegisterType = GetRegistryType(discrete.Direction, true),
Index = GetIndex(GetRegistryType(discrete.Direction, true)),
MaxValue = discrete.MaxValue,
MinValue = discrete.MinValue,
MeasurementType = discrete.MeasurementType,
Mrid = discrete.MRID,
NormalValue = discrete.NormalValue,
ObjectMrid = discrete.ObjectMRID ?? null,
TimeStamp = String.Empty,
Value = discrete.NormalValue,
Alarm = AlarmType.NO_ALARM
};
points.Add(new Tuple <RegisterType, int>(discretePoint.RegisterType, discretePoint.Index), discretePoint);
}
}
}
return(points);
}
public override string NextStep(char[,] grid, DiscretePoint bot)
{
throw new NotImplementedException();
}
public void ProccessDigital(DiscretePoint point)
{
point.TimeStamp = DateTime.Now.ToString();
ProccessDigitalAlarm(point);
}
public abstract string NextStep(char[,] grid, DiscretePoint bot);
public abstract bool CheckIfSolved(char[,] grid, DiscretePoint bot);
