public Animation(String path, int frameCount, int frameDelay, layer layer, origin origin, loopType loopType)
{
layers = 0;
currentX = 320;
currentY = 240;
currentAngle = 0;
totalCode = 0;
this.frameCount = frameCount;
this.frameDelay = frameDelay;
Add(string.Format("Animation,{0},{1},\"{2}\",320,240,{3},{4},{5}", layer, origin, path, frameCount, frameDelay, loopType));
layers++;
switch (layer)
{
case (layer.Foreground):
ControlClass.foreground.Add(this);
break;
case (layer.Background):
ControlClass.background.Add(this);
break;
case (layer.Pass):
ControlClass.pass.Add(this);
break;
case (layer.Fail):
ControlClass.fail.Add(this);
break;
}
}
private void layer_delay_ud_ValueChanged(object sender, EventArgs e)
{
layer l = layers[current_selected_layer];
l.delay = (int)layer_delay_ud.Value;
layers[current_selected_layer] = l;
}
private void layer_visible_up_ValueChanged(object sender, EventArgs e)
{
layer l = layers[current_selected_layer];
l.visibilty = (int)layer_visible_up.Value;
layers[current_selected_layer] = l;
}
///<summary>
///Initialize a new neural network with random synapse weights. First layer has size inputSizexhiddenLayerSize
///Hidden layers have size hiddenLayerSizexhiddenLayerSize, and output layer has size hiddenLayerSizexoutputSize
///Generates the specified number of hidden layers (>=0)
///</summary>
public net(int inputSize, int outputSize, int hiddenLayerNumbers, int hiddenLayerSize)
{
layers = new List <layer>();
if (hiddenLayerNumbers != 0)
{
firstLayer = new layer(inputSize, hiddenLayerSize);
layers.Add(firstLayer);
for (int i = 0; i < hiddenLayerNumbers - 1; i++)
{
layers.Add(new layer(layers.Last().size(), hiddenLayerSize));
}
outputLayer = new layer(layers.Last().size(), outputSize);
layers.Add(outputLayer);
layers[0].setDownstreamLayer(layers[1]);
layers[layers.Count - 1].setUpstreamLayer(layers[layers.Count - 2]);
for (int i = 1; i < layers.Count - 1; i++)
{
layers[i].setUpstreamLayer(layers[i - 1]);
layers[i].setDownstreamLayer(layers[i + 1]);
}
}
//If there are no hidden layers, the first layer is also the output layer
else
{
outputLayer = new layer(inputSize, outputSize);
firstLayer = outputLayer;
layers.Add(outputLayer);
}
}
private static CollisionFilter layerFilter(layer layer, layer disabled)
{
return(new CollisionFilter
{
CategoryBits = (uint)layer,
MaskBits = ~(uint)disabled,
GroupIndex = 0
});
}
private static CollisionFilter layerFilter(layer layer, layer disabled)
{
return(new CollisionFilter
{
BelongsTo = (uint)layer,
CollidesWith = ~(uint)disabled,
GroupIndex = 0
});
}
void OnGUI()
{
obj = (layer)EditorGUI.ObjectField(new Rect(3, 6, position.width - 6, 20), "Layer", obj, typeof(layer), true);
if (obj != null)
{
selectedTileX = EditorGUI.IntField(new Rect(3, 26, position.width - 6, 20), "Selected Tile X", obj.selectedX);
selectedTileY = EditorGUI.IntField(new Rect(3, 46, position.width - 6, 20), "Selected Tile Y", obj.selectedY);
EditorGUI.LabelField(new Rect(3, 66, position.width - 6, 20), "Initial X: " + obj.initX);
EditorGUI.LabelField(new Rect(3, 86, position.width - 6, 20), "Initial Y: " + obj.initY);
EditorGUI.LabelField(new Rect(3, 106, position.width - 6, 20), "Final X: " + obj.endX);
EditorGUI.LabelField(new Rect(3, 126, position.width - 6, 20), "Final Y: " + obj.endY);
if (selectedTileX >= 0 && selectedTileX < obj.width && selectedTileY >= 0 && selectedTileY < obj.height)
{
if (obj.map == null)
{
obj.map = new int[obj.width * obj.height];
for (int i = 0; i < obj.width; i++)
{
for (int j = 0; j < obj.height; j++)
{
obj.map[i + (obj.width * j)] = -1;
}
}
}
if (obj.state == 2)
{
int maxX = Mathf.Max(obj.initX, obj.endX);
int maxY = Mathf.Max(obj.initY, obj.endY);
string[] blocksTypes = new string[layer.AllBlocks.Length + 1];
blocksTypes[0] = "Empty Block";
for (int i = 1; i < blocksTypes.Length; i++)
{
blocksTypes[i] = layer.AllBlocks[i - 1].BlockName;
}
lastBlock = EditorGUI.Popup(new Rect(3, 186, 300, 20), lastBlock, blocksTypes);
for (int i = Mathf.Min(obj.initX, obj.endX); i <= maxX; i++)
{
for (int j = Mathf.Min(obj.initY, obj.endY); j <= maxY; j++)
{
obj.map[i + (obj.width * j)] = lastBlock - 1;
}
}
}
}
}
}
static private layer getLayerNum(int N)
{
layer ret = new layer();
// ??? 2^(N+2)-3??????2^(N+1)-1, ????2^(N+1)-2
long power = (long)Math.Pow(2, N + 1);
ret.total = power * 2 - 3;
ret.paty = power - 1;
ret.banz = power - 2;
return(ret);
}
static private long fullEat(int N, long X)
{
// ???1????? BPPPB????????????
if (N == 1)
{
long ret = 0;
if (X == 5)
{
ret = X - 2;
}
else
{
ret = X - 1;
}
return(ret);
}
// ?????????????
if (X <= 1)
{
// ???????????????
return(0);
}
layer burger = getLayerNum(N);
if (burger.total == X)
{
//???N??????????????
return(burger.paty);
}
if (X == (burger.total - 3) / 2 + 1)
{
// ???N-1??????????????????
return(getLayerNum(N - 1).paty);
}
else if (X == (burger.total - 3) / 2 + 2)
{
// ???????N-1????????????
return(getLayerNum(N - 1).paty + 1);
}
else if (X > (burger.total - 3) / 2 + 2)
{
// ???????N-1????????????????N-1???????????
layer burger_s = getLayerNum(N - 1);
long eated = burger_s.paty + 1;
long rest = X - (burger_s.total + 2);
return(eated + fullEat(N - 1, rest));
}
else
{
// ???N-1????????????????????????????????N-1???????????
return(fullEat(N - 1, X - 1));
}
}
/// <summary>
///
/// </summary>
private void AddFeatrueTypeAndLayer(string storepath, string Filename, Store store)
{
string[] filenames = Filename.Split('\\');
string tempFileName = filenames[filenames.Length - 1].Substring(0, filenames[filenames.Length - 1].LastIndexOf('.'));
if (!Directory.Exists(storepath + "\\" + tempFileName))
{
Directory.CreateDirectory(storepath + "\\" + tempFileName);
}
File.Copy(Application.StartupPath + "\\XmlTemplet\\Layer\\featuretype.xml", storepath + "\\" + tempFileName + "\\featuretype.xml");
FeatureType feature = new FeatureType();
feature.ID = "FeatureTypeInfoImpl--" + Guid.NewGuid().ToString();
string[] tempfiles = txt_shapepath.Text.Split('\\');
feature.Name = tempfiles[tempfiles.Length - 1].Substring(0, tempfiles[tempfiles.Length - 1].LastIndexOf('.'));
feature.NativeName = feature.Name;
feature.NamespaceID = SysParam.WordsSpaceSelected.ID.Replace("WorkspaceInfoImpl", "NamespaceInfoImpl");
feature.Title = feature.Name;
feature.Srs = "EPSG:4326";
feature.NativeBoundingBox_MinX = SysParam.MinX;
feature.NativeBoundingBox_MinY = SysParam.MinY;
feature.NativeBoundingBox_MaxX = SysParam.MaxX;
feature.NativeBoundingBox_MaxY = SysParam.MaxY;
feature.LatLonBoundingBox_MinX = SysParam.MinX;
feature.LatLonBoundingBox_MinY = SysParam.MinY;
feature.LatLonBoundingBox_MaxX = SysParam.MaxX;
feature.LatLonBoundingBox_MaxY = SysParam.MaxY;
feature.ProjectionPolicy = "FORCE_DECLARED";
feature.IsEnabled = "true";
feature.StoreID = store.ID;
feature.maxFeatures = "0";
feature.numDecimals = "0";
feature.overridingServiceSRS = "false";
feature.circularArcPresent = "false";
feature.SetAttribut(SysParam.WordsSpaceSelected, store, feature, storepath + "\\" + tempFileName + "\\featuretype.xml");
File.Copy(Application.StartupPath + "\\XmlTemplet\\Layer\\layer.xml", storepath + "\\" + tempFileName + "\\layer.xml");
layer _layer = new layer();
_layer.Name = feature.Name;
_layer.ID = "LayerInfoImpl--" + Guid.NewGuid().ToString();
_layer.Type = "VECTOR";
_layer.DefaultStyle_ID = "StyleInfoImpl--570ae188:124761b8d78:-7fe3";
_layer.resource_ID = feature.ID;
_layer.Attribution_LogoWidth = "0";
_layer.Attribution_LogoHeight = "0";
_layer.SetAttribut(feature, storepath + "\\" + tempFileName + "\\layer.xml");
}
/// <summary>
/// Adds a layer to the neural network.
/// </summary>
/// <param name="NumberOfNeurons">The number of neurons for the layer.</param>
/// <param name="NumberOfInputsPerNeuron">The number of inputs for each neuron in the layer.</param>
/// <param name="ActivationFunction">The activation function for the layer (The squashing function).</param>
/// <param name="bias">Whether to add a bais or not.</param>
public void addLayer(int NumberOfNeurons, int NumberOfInputsPerNeuron, int NumberOfOutputsPerNeuron, activationFunction ActivationFunction, bool bias)
{
layer l = new layer();
//l.init(x, y, logFunc);
if (layers.Count == 0)
{
l.init(NumberOfNeurons, NumberOfInputsPerNeuron, NumberOfOutputsPerNeuron, ActivationFunction, bias);
}
else
{
l.init(NumberOfNeurons, NumberOfInputsPerNeuron, NumberOfOutputsPerNeuron, ActivationFunction, bias); //true);
}
layers.Add(l);
}
///<summary>
///Restore net state from file
///</summary>
public void deserialize(string filename)
{
BinaryFormatter bf = new BinaryFormatter();
FileStream fs = new FileStream(filename, FileMode.Open);
//restore to array, build weights from array
List <layer> loadedLayers;
loadedLayers = (List <layer>)bf.Deserialize(fs);
fs.Close();
layers = loadedLayers;
firstLayer = layers[0];
outputLayer = layers.Last();
}
//ADD FRAME BTN
private void button2_Click(object sender, EventArgs e)
{
last_selected_layer = current_selected_layer;
layer tmp_layer = new layer();
tmp_layer.layer_name = "frame_" + layers.Count.ToString();
tmp_layer.visibilty = 255;
tmp_layer.delay = 100;
layer_delay_ud.Value = 100;
layer_visible_up.Value = 255;
tmp_layer.matrix_cid = new int[(int)matrix_size_widht.Value, (int)matrix_size_height.Value];
layers.Add(tmp_layer);
layers_listbox.Items.Add(tmp_layer.layer_name);
layers_listbox.SelectedItem = tmp_layer.layer_name;
exp_layer_cboxlist.Items.Add(tmp_layer.layer_name, true);
current_selected_layer = layers.Count - 1;
if (copy_frame_data_chbx.Checked)
{
tmp_layer.visibilty = layers[last_selected_layer].visibilty;
for (int i = 0; i < (int)matrix_size_widht.Value; i++)
{
for (int j = 0; j < (int)matrix_size_height.Value; j++)
{
layers[current_selected_layer].matrix_cid[i, j] = layers[last_selected_layer].matrix_cid[i, j];
}
}
}
//TODO REPLACE WITH REF IN STRUCT
for (int i = 0; i < (int)matrix_size_widht.Value; i++)
{
for (int j = 0; j < (int)matrix_size_height.Value; j++)
{
for (int k = 0; k < matrix_panel.Controls.Count; k++)
{
if (matrix_panel.Controls[k].Name == "mcell_" + i.ToString() + "_" + j.ToString())
{
matrix_panel.Controls[k].BackColor = colors[layers[current_selected_layer].matrix_cid[i, j]];
}
}
}
}
}
public void backwardHidden(layer myLayer, layer parentLayer)
{
double s = 0;
int index = Array.IndexOf(myLayer.neurons, this);
for (int i = 0; i < parentLayer.neurons.Length; i++)
{
s += parentLayer.neurons[i].weights[index] * parentLayer.neurons[i].delta;
}
//delta = output * (1 - output) * s;//* (output - expected);
delta = math.derLogisticsFunc(logFunc, inputs.summation((x, y) => x * weights[y])) * s;
//math.derLogisticsFunc(logFunc, inputs.summation((x, y) => x * weights[y])) = output * (1 - output)
for (int i = 0; i < dedw.Length; i++)
{
dedw[i] = delta * inputs[i];
}
}
private void set_matrix_size_btn_Click(object sender, EventArgs e)
{
//set_matrix_size_btn.Enabled = false;
matrix_panel.Controls.Clear();
// matrix_color_ids = new int[(int)matrix_size_widht.Value,(int)matrix_size_height.Value];
int mw_pixel = matrix_panel.Size.Width / (int)matrix_size_widht.Value;
int mh_pixel = matrix_panel.Size.Height / (int)matrix_size_height.Value;
matrix_size_w = (int)matrix_size_widht.Value;
matrix_size_h = (int)matrix_size_height.Value;
//CREATE LAYER
layer first_layer = new layer();
first_layer.layer_name = "<invalid_layer>";
first_layer.matrix_cid = new int[(int)matrix_size_widht.Value, (int)matrix_size_height.Value];
for (int i = 0; i < (int)matrix_size_widht.Value; i++)
{
for (int j = 0; j < (int)matrix_size_height.Value; j++)
{
PictureBox tmp = new PictureBox();
tmp.Size = new Size(mw_pixel, mh_pixel);
tmp.Location = new Point(i * mw_pixel, j * mh_pixel);
tmp.Name = "mcell_" + i.ToString() + "_" + j.ToString();
tmp.BackColor = colors[clear_color_id];
matrix_panel.Controls.Add(tmp);
tmp.Click += click_cell;
// first_layer.ref_box = tmp;
first_layer.matrix_cid[i, j] = clear_color_id;
}
}
first_layer.layer_name = "frame_" + layers.Count().ToString();
first_layer.visibilty = 255;
layer_visible_up.Value = 255;
first_layer.delay = 100;
layer_delay_ud.Value = 100;
layers.Add(first_layer);
layers_listbox.Items.Add(first_layer.layer_name);
layers_listbox.SelectedIndex = 0;
exp_layer_cboxlist.Items.Add(first_layer.layer_name, true);
}
//public neuralNet(int numIn, int numHiddenL, int numHiddenNeurons, int NumOutputs)
//{
// layers.Add(new layer(numIn,numIn));
//}
/// <summary>
/// Forward the specified inputs.
/// </summary>
/// <returns>The output of the network</returns>
/// <param name="inputs">Inputs for the network</param>
public double[] forward(double[] inputs)
{
bool inputLayer = true;
layer last = layers[0];
layers[0].outputs = inputs;
//layers[0].forward();
foreach (layer l in layers)
{
if (inputLayer)
{
inputLayer = false;
continue;
}
l.inputs = last.outputs;
l.forward();
last = l;
}
return(layers[layers.Count - 1].outputs);
}
public Sprite(String path, layer layer, origin origin)
{
layers = 0;
currentX = 320;
currentY = 240;
currentOpacity = 1;
currentScale = 1;
currentScaleX = 1;
currentScaleY = 1;
currentAngle = 0;
currentR = 255;
currentG = 255;
currentB = 255;
totalCode = 0;
this.path = path;
Add(string.Format("Sprite,{0},{1},\"{2}\",320,240", layer, origin, path));
layers++;
switch (layer)
{
case (layer.Foreground):
ControlClass.foreground.Add(this);
break;
case (layer.Background):
ControlClass.background.Add(this);
break;
case (layer.Pass):
ControlClass.pass.Add(this);
break;
case (layer.Fail):
ControlClass.fail.Add(this);
break;
}
}
// Start is called before the first frame update
void Start()
{
int maxPeaks = this.maxPeaks;
Mesh terrain = GameObject.Find("Terrain").GetComponent <Mesh>();
layer lastLayer = new layer();
lastLayer.maxDistance = this.maxDistance;
lastLayer.maxVertices = this.maxVertices;
for (int i = 0; i < height; i++)
{
int peaks = Random.Range(0, maxPeaks);
for (int j = 0; j < maxPeaks; j++)
{
}
maxPeaks /= 2;
}
// terrain.vertices =
// terrain.terrainData.heightmapTexture
}
public void CustomizePrefab(GameObject prefab)
{
prefab.AddComponent <layer>();
l = prefab.GetComponent <layer>();
TiledMap tm = prefab.GetComponent <TiledMap>();
l.blockSize = tm.TileHeight;
l.width = tm.NumTilesWide;
l.height = tm.NumTilesHigh;
l.map = new int[l.width * l.height];
for (int i = 0; i < l.width; i++)
{
for (int j = 0; j < l.height; j++)
{
l.map[i + (l.width * j)] = -1;
}
}
}
public void Dispose(bool disposing)
{
this.window.Children.Remove((FrameworkElement)_layer);
this._layer.Dispose();
this._layer = null;
this.thread.Do((Action)(() =>
{
this.renderframe?.Dispose();
this.opentk?.Dispose();
ready.Set();
this.window.SizeChanged -= Ctl_SizeChanged;
if (this.olddepth != null)
{
this.device.DepthStencilSurface = this.olddepth;
this.olddepth?.Dispose();
this.olddepth = null;
}
this.frame?.Dispose();
this.Xwt.FreeWindowInfo(this.widget);
depthsurface?.Dispose(); depthsurface = null;
depthtexture?.Dispose(); depthtexture = null;
effect3?.Dispose(); effect3 = null;
effect2?.Dispose(); effect2 = null;
presenteffect?.Dispose(); presenteffect = null;
vertices2?.Dispose(); vertices2 = null;
indices?.Dispose(); indices = null;
device?.Dispose(); device = null;
direct3D?.Dispose(); direct3D = null;
}));
this.thread.Dispose();
}
public synapse.Synapse CreateSynapse(layer.Layer layer, Neuron neuron)
{
return null;
}
public Sprite(String path, layer layer)
: this(path, layer, origin.Centre)
{
}
public override CALayer MakeBackingLayer()
{
var l = new layer(this);
return(l);
}
public room_object_header()
{
layers = new layer[object_data.layerNo];
}
public override void up(MobileObject target, Transform contactPoint, float x, float y, int blockSize, layer l)
{
if (!target.Solid) return;
float contactY = contactPoint.position.y;
if ((target.YSpeed <= 0 && contactY - y <= 7) || target.GuidedByTerrain)
{
target.BlockedFromBelow = true;
}
}
public override void right(MobileObject target, Transform contactPoint, float x, float y, int blockSize, layer l)
{
if (!target.Solid || (target.TerrainAngle < 0 && target.BlockedFromBelow)) return;
float contactY = contactPoint.position.y;
if (target.YSpeed <= 0 && contactY - y <= 7 && target.XSpeed < 0 && contactPoint.position.x < (x + 15))
{
target.BlockedFromLeft = true;
target.x += (x + 15) - contactPoint.position.x;
target.XSpeed = 0;
}
}
public override void down(MobileObject target, Transform contactPoint, float x, float y, int blockSize, layer l)
{
throw new NotImplementedException();
}
public override void angleDetector(MobileObject target, Transform contactPoint, float x, float y, int blockSize, layer l)
{
if (!target.Solid) return;
float contactY = contactPoint.position.y;
if ((target.YSpeed <= 0 && contactY - y <= 7) || target.GuidedByTerrain)
{
target.y += (y + 7) - contactY;
target.TerrainAngle = 0;
target.BlockedAngleDetector = true;
}
}
!((ext = IsInstanceExtensionPresent(layer, ExtensionAttribute.GetExtensionAttribute(typeof(T)).Name)
// Execute: Execute the function given the array of the parameters
public void Execute(IArray paramvalues, ITrackCancel trackcancel, IGPEnvironmentManager envMgr, IGPMessages message)
{
IFeatureClass outputFeatureClass = null;
try
{
// get the input feature class
IGPMultiValue inputFeatureClasses_Parameter = (IGPMultiValue)m_GPUtilities.UnpackGPValue(paramvalues.get_Element(0));
layer[] input_featureClasses = new layer[inputFeatureClasses_Parameter.Count];
for (int i = 0; i < inputFeatureClasses_Parameter.Count; i++)
{
IGPValue inputFeatureClass_Parameter = inputFeatureClasses_Parameter.get_Value(i);
IFeatureClass inputFeatureClass;
IQueryFilter inputQF;
m_GPUtilities.DecodeFeatureLayer(inputFeatureClass_Parameter, out inputFeatureClass, out inputQF);
input_featureClasses[i] = new layer()
{
featureclass = inputFeatureClass, qFilter = inputQF
};
}
if (input_featureClasses.Length == 0 || input_featureClasses.Any(w => w.featureclass == null))
{
message.AddError(2, "Could not open one or more input dataset.");
return;
}
//IFields additionalFields = new FieldsClass();
//additionalFields.AddField(FEATURE_SOURCE_FIELD_NAME, esriFieldType.esriFieldTypeString);
//additionalFields.AddField(FEATURE_ID_FIELD_NAME, esriFieldType.esriFieldTypeInteger);
//additionalFields.AddField(
// input_featureClasses[0].featureclass.Fields.get_Field(
// input_featureClasses[0].featureclass.Fields.FindField(
// input_featureClasses[0].featureclass.ShapeFieldName)));
// create the output feature class
IGPValue outputFeatureClass_Parameter = m_GPUtilities.UnpackGPValue(paramvalues.get_Element(1));
outputFeatureClass = GPHelperFunctions.CreateFeatureClass(outputFeatureClass_Parameter, envMgr);
if (outputFeatureClass == null)
{
message.AddError(2, "Could not create output dataset.");
return;
}
IGPString curveTypeParameter = (IGPString)m_GPUtilities.UnpackGPValue(paramvalues.get_Element(2));
ArcConstructionMethods method;
if (!Enum.TryParse <ArcConstructionMethods>(curveTypeParameter.Value, true, out method))
{
message.AddError(2, string.Format("The value {0} is not expected. Expected values are: {1}.",
curveTypeParameter.Value,
string.Join(",", Enum.GetNames(typeof(ArcConstructionMethods)))));
return;
}
IStepProgressor stepPro = (IStepProgressor)trackcancel;
GPHelperFunctions.dropSpatialIndex(outputFeatureClass);
BoostVoronoi bv = new BoostVoronoi(100);
double minX = int.MaxValue, minY = int.MaxValue, maxX = int.MinValue, maxY = int.MinValue;
List <site_key> point_sites = new List <site_key>();
List <site_key> segment_sites = new List <site_key>();
for (short i = 0; i < input_featureClasses.Length; i++)
{
layer l = input_featureClasses[i];
int featcount = l.featureclass.FeatureCount(l.qFilter);
stepPro.MinRange = 0;
stepPro.MaxRange = featcount;
stepPro.StepValue = (1);
stepPro.Message = "Reading features";
stepPro.Position = 0;
stepPro.Show();
IFeatureCursor cursor = null;
IFeature row = null;
try
{
cursor = l.featureclass.Search(l.qFilter, false);
while ((row = cursor.NextFeature()) != null)
{
stepPro.Step();
IPoint point = row.Shape as IPoint;
if (point != null)
{
double X = point.X;
double Y = point.Y;
minX = Math.Min(minX, X);
maxX = Math.Max(maxX, X);
minY = Math.Min(minY, Y);
maxY = Math.Max(maxY, Y);
bv.AddPoint(point.X, point.Y);
point_sites.Add(new site_key(i, row.OID));
}
IMultipoint multipoint = row.Shape as IMultipoint;
if (multipoint != null)
{
IPointCollection pointCollection = (IPointCollection)multipoint;
IEnumVertex vertices = pointCollection.EnumVertices;
IPoint vertex = null; int part, index;
vertices.Next(out vertex, out part, out index);
minX = Math.Min(minX, multipoint.Envelope.XMin);
maxX = Math.Max(maxX, multipoint.Envelope.XMax);
minY = Math.Min(minY, multipoint.Envelope.YMin);
maxY = Math.Max(maxY, multipoint.Envelope.YMax);
while (vertex != null)
{
bv.AddPoint(vertex.X, vertex.Y);
point_sites.Add(new site_key(i, row.OID));
vertices.Next(out vertex, out part, out index);
}
}
IPolyline polyline = row.Shape as IPolyline;
if (polyline != null)
{
double fromX = polyline.FromPoint.X;
double fromY = polyline.FromPoint.Y;
double toX = polyline.ToPoint.X;
double toY = polyline.ToPoint.Y;
if (toX < fromX)
{
minX = Math.Min(minX, toX);
maxX = Math.Max(maxX, fromX);
}
else
{
minX = Math.Min(minX, fromX);
maxX = Math.Max(maxX, toX);
}
if (toY < fromY)
{
minY = Math.Min(minY, toY);
maxY = Math.Max(maxY, fromY);
}
else
{
minY = Math.Min(minY, fromY);
maxY = Math.Max(maxY, toY);
}
bv.AddSegment(
polyline.FromPoint.X, polyline.FromPoint.Y,
polyline.ToPoint.X, polyline.ToPoint.Y
);
segment_sites.Add(new site_key(i, row.OID));
}
Marshal.ReleaseComObject(row);
}
}
finally
{
if (row != null)
{
Marshal.ReleaseComObject(row);
}
if (cursor != null)
{
Marshal.ReleaseComObject(cursor);
}
stepPro.Hide();
}
}
message.AddMessage(String.Format("{0}, {1} -> {2}, {3}", minX, minY, maxX, maxY));
int width = Math.Max((int)((maxX - minX) * 0.1), 1);
int height = Math.Max((int)((maxY - minY) * 0.1), 1);
maxX = maxX + width;
minX = minX - width;
maxY = maxY + height;
minY = minY - height;
message.AddMessage(String.Format("{0}, {1} -> {2}, {3}", minX, minY, maxX, maxY));
bv.AddSegment(minX, minY, maxX, minY);
segment_sites.Add(new site_key(-1, -1));
bv.AddSegment(maxX, minY, maxX, maxY);
segment_sites.Add(new site_key(-1, -1));
bv.AddSegment(maxX, maxY, minX, maxY);
segment_sites.Add(new site_key(-1, -1));
bv.AddSegment(minX, maxY, minX, minY);
segment_sites.Add(new site_key(-1, -1));
stepPro.Message = "Solve Voronoi";
stepPro.MaxRange = 0;
stepPro.MaxRange = 0;
stepPro.Show();
bv.Construct();
stepPro.Hide();
int featureSourceIndx = outputFeatureClass.Fields.FindField(FEATURE_SOURCE_FIELD_NAME);
int featureIDIndx = outputFeatureClass.Fields.FindField(FEATURE_ID_FIELD_NAME);
IFeatureCursor inserts = null;
IFeatureBuffer buffer = null;
try
{
object missing = Type.Missing;
ISpatialReference spatialReference = ((IGeoDataset)outputFeatureClass).SpatialReference;
inserts = outputFeatureClass.Insert(false);
buffer = outputFeatureClass.CreateFeatureBuffer();
List <Cell> cells = bv.Cells;
message.AddMessage(string.Format("{0} cells calculated", cells.Count));
List <Edge> edges = bv.Edges;
message.AddMessage(string.Format("{0} edges calculated", edges.Count));
List <Vertex> vertices = bv.Vertices;
message.AddMessage(string.Format("{0} vertexes calculated", vertices.Count));
stepPro.Message = "Write cells";
stepPro.MaxRange = 0;
stepPro.MaxRange = cells.Count;
stepPro.Show();
for (int cellIndex = 0; cellIndex < cells.Count; cellIndex++)
{
try
{
if (cellIndex % 5000 == 0)
{
message.AddMessage(String.Format("{0}. {1} cells processed.", DateTime.Now, cellIndex));
}
Cell cell = cells[cellIndex];
int currentSite = cell.Site;
IGeometryCollection geometryCollection = new GeometryBagClass()
{
SpatialReference = spatialReference
};
//ignores any sliver cells
if (cell.IsOpen || cell.EdgesIndex.Count < 3)
{
continue;
}
ISegmentCollection segmentCollection = createSegments(cell, bv, method, spatialReference);
if (((IArea)segmentCollection).Area <= 0)
{
message.AddMessage("A invalid geometry has been detected, try reversing the orientation.");
ISegmentCollection reversed_segmentCollection = new PolygonClass()
{
SpatialReference = spatialReference
};
for (int i = segmentCollection.SegmentCount - 1; i >= 0; i--)
{
ISegment segment = (ISegment)segmentCollection.get_Segment(i);
segment.ReverseOrientation();
reversed_segmentCollection.AddSegment(segment);
}
segmentCollection = reversed_segmentCollection;
}
((IPolygon)segmentCollection).SpatialReference = spatialReference;
if (((IArea)segmentCollection).Area <= 0)
{
message.AddWarning("An empty shell has been created");
for (int i = 0; i < segmentCollection.SegmentCount; i++)
{
ISegment segment = (ISegment)segmentCollection.get_Segment(i);
message.AddMessage(String.Format("From {0}, {1} To {2},{3}",
segment.FromPoint.X, segment.FromPoint.Y,
segment.ToPoint.X, segment.ToPoint.Y));
}
}
//set attributes
site_key sk = (currentSite >= point_sites.Count) ? segment_sites[currentSite - point_sites.Count] : point_sites[currentSite];
if (!sk.isEmpty)
{
buffer.set_Value(featureSourceIndx, input_featureClasses[sk.featureClassIndex].featureclass.AliasName);
buffer.set_Value(featureIDIndx, sk.objectID);
}
else
{
buffer.set_Value(featureSourceIndx, DBNull.Value);
buffer.set_Value(featureIDIndx, DBNull.Value);
}
IPolygon voronoiPolygon = (IPolygon)segmentCollection;
buffer.Shape = (IPolygon)voronoiPolygon;
inserts.InsertFeature(buffer);
}
catch (Exception e)
{
message.AddWarning("Failed to create a cell");
}
}
}
finally
{
if (buffer != null)
{
Marshal.ReleaseComObject(buffer);
}
if (inserts != null)
{
Marshal.ReleaseComObject(inserts);
}
}
GPHelperFunctions.createSpatialIndex(outputFeatureClass);
}
catch (Exception exx)
{
message.AddError(2, exx.Message);
message.AddMessage(exx.ToString());
}
finally
{
if (outputFeatureClass != null)
{
Marshal.ReleaseComObject(outputFeatureClass);
}
((IProgressor)trackcancel).Hide();
}
}
public Animation(String path, int frameCount, int frameDelay, layer layer, loopType loopType)
: this(path, frameCount, frameDelay, layer, origin.Centre, loopType)
{
}
public Animation(String path, int frameCount, int frameDelay, layer layer, origin origin)
: this(path, frameCount, frameDelay, layer, origin, loopType.LoopForever)
{
}
public void setUpstreamLayer(layer newUpstreamLayer)
{
upstreamLayer = newUpstreamLayer;
}
public override void right(MobileObject target, Transform contactPoint, float x, float y, int blockSize, layer l)
{
if (!target.Solid)
{
return;
}
if (target.XSpeed < 0 && contactPoint.position.x < (x + 15))
{
target.BlockedFromLeft = true;
target.x += (x + 15) - contactPoint.position.x;
target.XSpeed = 0;
}
}
public override void up(MobileObject target, Transform contactPoint, float x, float y, int blockSize, layer l)
{
if (!target.Solid)
{
return;
}
if (target.YSpeed <= 0 || target.GuidedByTerrain)
{
target.BlockedFromBelow = true;
}
}
public void setDownstreamLayer(layer newDownstreamLayer)
{
downstreamLayer = newDownstreamLayer;
}
// Execute: Execute the function given the array of the parameters
public void Execute(IArray paramvalues, ITrackCancel trackcancel, IGPEnvironmentManager envMgr, IGPMessages message)
{
IFeatureClass outputFeatureClass = null;
try
{
// get the input feature class
IGPMultiValue inputFeatureClasses_Parameter = (IGPMultiValue)m_GPUtilities.UnpackGPValue(paramvalues.get_Element(0));
layer[] input_featureClasses = new layer[inputFeatureClasses_Parameter.Count];
for (int i = 0; i < inputFeatureClasses_Parameter.Count; i++)
{
IGPValue inputFeatureClass_Parameter = inputFeatureClasses_Parameter.get_Value(i);
IFeatureClass inputFeatureClass;
IQueryFilter inputQF;
m_GPUtilities.DecodeFeatureLayer(inputFeatureClass_Parameter, out inputFeatureClass, out inputQF);
input_featureClasses[i] = new layer() { featureclass = inputFeatureClass, qFilter = inputQF};
}
if (input_featureClasses.Length == 0 || input_featureClasses.Any(w=> w.featureclass == null))
{
message.AddError(2, "Could not open one or more input dataset.");
return;
}
//IFields additionalFields = new FieldsClass();
//additionalFields.AddField(FEATURE_SOURCE_FIELD_NAME, esriFieldType.esriFieldTypeString);
//additionalFields.AddField(FEATURE_ID_FIELD_NAME, esriFieldType.esriFieldTypeInteger);
//additionalFields.AddField(
// input_featureClasses[0].featureclass.Fields.get_Field(
// input_featureClasses[0].featureclass.Fields.FindField(
// input_featureClasses[0].featureclass.ShapeFieldName)));
// create the output feature class
IGPValue outputFeatureClass_Parameter = m_GPUtilities.UnpackGPValue(paramvalues.get_Element(1));
outputFeatureClass = GPHelperFunctions.CreateFeatureClass(outputFeatureClass_Parameter, envMgr);
if (outputFeatureClass == null)
{
message.AddError(2, "Could not create output dataset.");
return;
}
IGPString curveTypeParameter = (IGPString)m_GPUtilities.UnpackGPValue(paramvalues.get_Element(2));
ArcConstructionMethods method;
if (!Enum.TryParse<ArcConstructionMethods>(curveTypeParameter.Value, true, out method))
{
message.AddError(2, string.Format("The value {0} is not expected. Expected values are: {1}.",
curveTypeParameter.Value,
string.Join(",", Enum.GetNames(typeof(ArcConstructionMethods)))));
return;
}
IStepProgressor stepPro = (IStepProgressor)trackcancel;
GPHelperFunctions.dropSpatialIndex(outputFeatureClass);
BoostVoronoi bv = new BoostVoronoi(100);
double minX = int.MaxValue, minY = int.MaxValue, maxX = int.MinValue, maxY = int.MinValue;
List<site_key> point_sites = new List<site_key>();
List<site_key> segment_sites = new List<site_key>();
for (short i = 0; i < input_featureClasses.Length; i++)
{
layer l = input_featureClasses[i];
int featcount = l.featureclass.FeatureCount(l.qFilter);
stepPro.MinRange = 0;
stepPro.MaxRange = featcount;
stepPro.StepValue = (1);
stepPro.Message = "Reading features";
stepPro.Position = 0;
stepPro.Show();
IFeatureCursor cursor = null;
IFeature row = null;
try
{
cursor = l.featureclass.Search(l.qFilter, false);
while ((row = cursor.NextFeature()) != null)
{
stepPro.Step();
IPoint point = row.Shape as IPoint;
if (point != null)
{
double X = point.X;
double Y = point.Y;
minX = Math.Min(minX, X);
maxX = Math.Max(maxX, X);
minY = Math.Min(minY, Y);
maxY = Math.Max(maxY, Y);
bv.AddPoint(point.X, point.Y);
point_sites.Add(new site_key(i, row.OID));
}
IMultipoint multipoint = row.Shape as IMultipoint;
if (multipoint != null)
{
IPointCollection pointCollection = (IPointCollection)multipoint;
IEnumVertex vertices = pointCollection.EnumVertices;
IPoint vertex = null; int part, index;
vertices.Next(out vertex, out part, out index);
minX = Math.Min(minX, multipoint.Envelope.XMin);
maxX = Math.Max(maxX, multipoint.Envelope.XMax);
minY = Math.Min(minY, multipoint.Envelope.YMin);
maxY = Math.Max(maxY, multipoint.Envelope.YMax);
while (vertex != null)
{
bv.AddPoint(vertex.X, vertex.Y);
point_sites.Add(new site_key(i, row.OID));
vertices.Next(out vertex, out part, out index);
}
}
IPolyline polyline = row.Shape as IPolyline;
if (polyline != null)
{
double fromX = polyline.FromPoint.X;
double fromY = polyline.FromPoint.Y;
double toX = polyline.ToPoint.X;
double toY = polyline.ToPoint.Y;
if (toX < fromX)
{
minX = Math.Min(minX, toX);
maxX = Math.Max(maxX, fromX);
}
else
{
minX = Math.Min(minX, fromX);
maxX = Math.Max(maxX, toX);
}
if (toY < fromY)
{
minY = Math.Min(minY, toY);
maxY = Math.Max(maxY, fromY);
}
else
{
minY = Math.Min(minY, fromY);
maxY = Math.Max(maxY, toY);
}
bv.AddSegment(
polyline.FromPoint.X, polyline.FromPoint.Y,
polyline.ToPoint.X, polyline.ToPoint.Y
);
segment_sites.Add(new site_key(i, row.OID));
}
Marshal.ReleaseComObject(row);
}
}
finally
{
if (row != null) Marshal.ReleaseComObject(row);
if (cursor != null) Marshal.ReleaseComObject(cursor);
stepPro.Hide();
}
}
message.AddMessage(String.Format("{0}, {1} -> {2}, {3}", minX, minY, maxX, maxY));
int width = Math.Max((int)((maxX - minX) * 0.1), 1);
int height = Math.Max((int)((maxY - minY) * 0.1), 1);
maxX = maxX + width;
minX = minX - width;
maxY = maxY + height;
minY = minY - height;
message.AddMessage(String.Format("{0}, {1} -> {2}, {3}", minX, minY, maxX, maxY));
bv.AddSegment(minX, minY, maxX, minY);
segment_sites.Add(new site_key(-1, -1));
bv.AddSegment(maxX, minY, maxX, maxY);
segment_sites.Add(new site_key(-1, -1));
bv.AddSegment(maxX, maxY, minX, maxY);
segment_sites.Add(new site_key(-1, -1));
bv.AddSegment(minX, maxY, minX, minY);
segment_sites.Add(new site_key(-1, -1));
stepPro.Message = "Solve Voronoi";
stepPro.MaxRange = 0;
stepPro.MaxRange = 0;
stepPro.Show();
bv.Construct();
stepPro.Hide();
int featureSourceIndx = outputFeatureClass.Fields.FindField(FEATURE_SOURCE_FIELD_NAME);
int featureIDIndx = outputFeatureClass.Fields.FindField(FEATURE_ID_FIELD_NAME);
IFeatureCursor inserts = null;
IFeatureBuffer buffer = null;
try
{
object missing = Type.Missing;
ISpatialReference spatialReference = ((IGeoDataset)outputFeatureClass).SpatialReference;
inserts = outputFeatureClass.Insert(false);
buffer = outputFeatureClass.CreateFeatureBuffer();
List<Cell> cells = bv.Cells;
message.AddMessage(string.Format("{0} cells calculated", cells.Count));
List<Edge> edges = bv.Edges;
message.AddMessage(string.Format("{0} edges calculated", edges.Count));
List<Vertex> vertices = bv.Vertices;
message.AddMessage(string.Format("{0} vertexes calculated", vertices.Count));
stepPro.Message = "Write cells";
stepPro.MaxRange = 0;
stepPro.MaxRange = cells.Count;
stepPro.Show();
for (int cellIndex = 0; cellIndex < cells.Count; cellIndex++)
{
try
{
if(cellIndex % 5000 == 0) message.AddMessage(String.Format("{0}. {1} cells processed.", DateTime.Now, cellIndex));
Cell cell = cells[cellIndex];
int currentSite = cell.Site;
IGeometryCollection geometryCollection = new GeometryBagClass() { SpatialReference = spatialReference };
//ignores any sliver cells
if (cell.IsOpen || cell.EdgesIndex.Count < 3)
continue;
ISegmentCollection segmentCollection = createSegments(cell, bv, method, spatialReference);
if (((IArea)segmentCollection).Area <= 0)
{
message.AddMessage("A invalid geometry has been detected, try reversing the orientation.");
ISegmentCollection reversed_segmentCollection = new PolygonClass() { SpatialReference = spatialReference };
for (int i = segmentCollection.SegmentCount - 1; i >= 0; i--)
{
ISegment segment = (ISegment)segmentCollection.get_Segment(i);
segment.ReverseOrientation();
reversed_segmentCollection.AddSegment(segment);
}
segmentCollection = reversed_segmentCollection;
}
((IPolygon)segmentCollection).SpatialReference = spatialReference;
if (((IArea)segmentCollection).Area <= 0)
{
message.AddWarning("An empty shell has been created");
for (int i = 0; i < segmentCollection.SegmentCount; i++)
{
ISegment segment = (ISegment)segmentCollection.get_Segment(i);
message.AddMessage(String.Format("From {0}, {1} To {2},{3}",
segment.FromPoint.X, segment.FromPoint.Y,
segment.ToPoint.X, segment.ToPoint.Y));
}
}
//set attributes
site_key sk = (currentSite >= point_sites.Count) ? segment_sites[currentSite - point_sites.Count] : point_sites[currentSite];
if (!sk.isEmpty)
{
buffer.set_Value(featureSourceIndx, input_featureClasses[sk.featureClassIndex].featureclass.AliasName);
buffer.set_Value(featureIDIndx, sk.objectID);
}
else
{
buffer.set_Value(featureSourceIndx, DBNull.Value);
buffer.set_Value(featureIDIndx, DBNull.Value);
}
IPolygon voronoiPolygon = (IPolygon)segmentCollection;
buffer.Shape = (IPolygon)voronoiPolygon;
inserts.InsertFeature(buffer);
}
catch (Exception e)
{
message.AddWarning("Failed to create a cell");
}
}
}
finally
{
if (buffer != null) Marshal.ReleaseComObject(buffer);
if (inserts != null) Marshal.ReleaseComObject(inserts);
}
GPHelperFunctions.createSpatialIndex(outputFeatureClass);
}
catch (Exception exx)
{
message.AddError(2, exx.Message);
message.AddMessage(exx.ToString());
}
finally
{
if (outputFeatureClass != null) Marshal.ReleaseComObject(outputFeatureClass);
((IProgressor)trackcancel).Hide();
}
}
