public GrassPatchSceneNode(SceneNode parent, SceneManager mgr, int id, bool createIfEmpty, Vector3D gridPos, string filepath, Texture heightMap, Texture colourMap, Texture grassMap, SceneNode terrain, WindGenerator wind) : base(parent, mgr, id) { DrawDistance = GRASS_PATCH_SIZE * 1.5f; MaxDensity = 800; TerrainHeightMap = heightMap; TerrainColourMap = colourMap; TerrainGrassMap = grassMap; Terrain = terrain; WindGen = wind; lastwindtime = 0; lastdrawcount = 0; redrawnextloop = true; MaxFPS = 0; _mgr = mgr; WindRes = 5; filename = string.Format("{0}/{1}.{2}.grass", filepath, gridpos.X, gridpos.Z); gridpos = gridPos; Position = new Vector3D(gridpos.X * GRASS_PATCH_SIZE, 0f, gridpos.Z * GRASS_PATCH_SIZE); ImageCount = new Dimension2D(4, 2); if (!Load()) Create(createIfEmpty); }
protected internal override void OnRender(RenderEventArgs e) { e.Canvas.Color = mvarForegroundColor; e.Canvas.Translate(0, 12); double x = 0, y = 0; switch (mvarHorizontalAlignment) { case Caltron.HorizontalAlignment.Center: { Dimension2D dim = e.Canvas.MeasureText(base.Text); x = ((Size.Width + dim.Width) / 2); break; } case Caltron.HorizontalAlignment.Right: { Dimension2D dim = e.Canvas.MeasureText(base.Text); x = (Size.Width - dim.Width); break; } } e.Canvas.DrawText(base.Text, x, y); e.Canvas.Translate(0, -12); }
/// <summary> /// Creates and adds specified number of feature maps to this layer /// </summary> /// <param name="mapCount"> number of feature maps to create </param> /// <param name="dimensions"> feature map dimensions </param> /// <param name="neuronProperties"> properties of neurons in feature maps </param> protected internal void createFeatureMaps(int mapCount, Dimension2D mapDimensions, Dimension2D kernelDimension, NeuronProperties neuronProperties) { for (int i = 0; i < mapCount; i++) { addFeatureMap(new FeatureMapLayer(mapDimensions, neuronProperties, kernelDimension)); } }
public LayerVisialize(FeatureMapsLayer featureMapsLayer) { this.layerMaps = new List <>(); this.featureMapsLayer = featureMapsLayer; this.mapDimensions = featureMapsLayer.MapDimensions; initWeights(); }
private void createFeatureMaps(int mapCount, Dimension2D mapDimensions, NeuronProperties neuronProperties) { for (int i = 0; i < mapCount; i++) { addFeatureMap(new FeatureMapLayer(mapDimensions, neuronProperties)); } }
public ProcessingResult <ICroppedArea> ExtractRegionOfInterestFrom(ICroppedArea areaOfExtraction) { using (areaOfExtraction) { List <OrderedBitmap> extractedRegionsOfInterest = new List <OrderedBitmap>(); foreach (var areaPart in areaOfExtraction.CroppedParts) { var partBytes = areaPart.Bitmap.AsFlattenedByteArray(); var leftEdge = GetLeftEdgeOfRegionOfInterest(partBytes); var rightEdge = GetRightEdgeOfRegionOfInterest(partBytes); var topEdge = GetTopEdgeOfRegionOfInterest(partBytes); var bottomEdge = GetBottomEdgeOfRegionOfInterest(partBytes); if (leftEdge == null || rightEdge == null || topEdge == null || bottomEdge == null || (bottomEdge.Value - topEdge.Value) < 10) { //Nothing interesting - return empty result extractedRegionsOfInterest.Add(new OrderedBitmap(areaPart.Order, null)); continue; } var size = new Dimension2D(rightEdge.Value - leftEdge.Value + 1, bottomEdge.Value - topEdge.Value + 1) .GetInputSizeAsMultipliesOfFour().AsSize(); var croppedBitmap = new Crop(new Rectangle(new Point(leftEdge.Value, topEdge.Value), size)).Apply(areaPart.Bitmap); extractedRegionsOfInterest.Add(new OrderedBitmap(areaPart.Order, croppedBitmap)); } return(ProcessingResult <ICroppedArea> .Success( new CroppedArea(areaOfExtraction.AreaUsedForCropping, extractedRegionsOfInterest, areaOfExtraction.DocumentId))); } }
/// <summary> /// Creates new feature maps layer with specified kernel and feature maps. /// Also creates feature maps and neurons in feature maps; /// </summary> /// <param name="kernel"> kernel used for all feature maps in this layer </param> /// <param name="mapDimensions"> mapDimensions of feature maps in this layer </param> /// <param name="mapCount"> number of feature maps </param> /// <param name="neuronProp"> properties for neurons in feature maps </param> public FeatureMapsLayer(Dimension2D kernelDimension, Dimension2D mapDimensions, int mapCount, NeuronProperties neuronProp) { // this.kernel = kernel; this.mapDimensions = mapDimensions; this.featureMaps = new List <FeatureMapLayer>(); createFeatureMaps(mapCount, mapDimensions, kernelDimension, neuronProp); }
/// <summary> /// Creates 2D layer with specified dimensions, filled with neurons with /// specified properties /// </summary> /// <param name="dimensions"> layer dimensions </param> /// <param name="neuronProperties"> neuron properties </param> public FeatureMapLayer(Dimension2D dimensions, NeuronProperties neuronProperties, Dimension2D kernelDimension) : this(dimensions, kernelDimension) { for (int i = 0; i < dimensions.Height * dimensions.Width; i++) { Neuron neuron = NeuronFactory.createNeuron(neuronProperties); addNeuron(neuron); } }
/// <summary> /// Creates an empty 2D layer with specified dimensions /// </summary> /// <param name="dimensions"> layer dimensions (width and weight) </param> public FeatureMapLayer(Dimension2D dimensions, NeuronProperties neuronProperties) { this.dimensions = dimensions; for (int i = 0; i < dimensions.Height * dimensions.Width; i++) { Neuron neuron = NeuronFactory.createNeuron(neuronProperties); addNeuron(neuron); } }
/// <summary> /// Creates convolutional layer with specified kernel, and appropriate map /// dimensions in regard to previous layer - fromLayer param /// </summary> /// <param name="fromLayer"> previous layer, which will be connected to this layer </param> /// <param name="kernel"> kernel for all feature maps in this layer </param> // public ConvolutionalLayer(FeatureMapsLayer fromLayer, Kernel kernel) { // Dimension2D fromDimension = fromLayer.getMapDimensions(); // int mapWidth = fromDimension.getWidth() - (kernel.getWidth() - 1); // int mapHeight = fromDimension.getHeight() - (kernel.getHeight() - 1); // this.mapDimensions = new Dimension2D(mapWidth, mapHeight); // // createFeatureMaps(1, this.mapDimensions, ConvolutionalLayer.DEFAULT_NEURON_PROP); // } /// <summary> /// Creates convolutional layer with specified kernel, appropriate map /// dimensions in regard to previous layer (fromLayer param) and specified /// number of feature maps with default neuron settings for convolutional /// layer. /// </summary> /// <param name="fromLayer"> previous layer, which will be connected to this layer </param> /// <param name="kernel"> kernel for all feature maps </param> /// <param name="numberOfMaps"> number of feature maps to create in this layer </param> public ConvolutionalLayer(FeatureMapsLayer fromLayer, Dimension2D kernelDimension, int numberOfMaps) { Dimension2D fromDimension = fromLayer.MapDimensions; int mapWidth = fromDimension.Width - kernelDimension.Width + 1; int mapHeight = fromDimension.Height - kernelDimension.Height + 1; this.mapDimensions = new Dimension2D(mapWidth, mapHeight); createFeatureMaps(numberOfMaps, this.mapDimensions, kernelDimension, ConvolutionalLayer.DEFAULT_NEURON_PROP); }
/// <summary> /// Creates convolutional layer with specified kernel, appropriate map /// dimensions in regard to previous layer (fromLayer param) and specified /// number of feature maps with given neuron properties. /// </summary> /// <param name="fromLayer"> previous layer, which will be connected to this layer </param> /// <param name="kernel"> kernel for all feature maps </param> /// <param name="numberOfMaps"> number of feature maps to create in this layer </param> /// <param name="neuronProp"> settings for neurons in feature maps </param> public ConvolutionalLayer(FeatureMapsLayer fromLayer, Dimension2D kernelDimension, int numberOfMaps, NeuronProperties neuronProp) { Dimension2D fromDimension = fromLayer.MapDimensions; int mapWidth = fromDimension.Width - kernelDimension.Width + 1; int mapHeight = fromDimension.Height - kernelDimension.Height + 1; this.mapDimensions = new Dimension2D(mapWidth, mapHeight); createFeatureMaps(numberOfMaps, this.mapDimensions, kernelDimension, neuronProp); }
/// <summary> /// Creates pooling layer with specified kernel, appropriate map /// dimensions in regard to previous layer (fromLayer param) and specified /// number of feature maps with given neuron properties. /// </summary> /// <param name="fromLayer"> previous layer, which will be connected to this layer </param> /// <param name="kernel"> kernel for all feature maps </param> /// <param name="numberOfMaps"> number of feature maps to create in this layer </param> /// <param name="neuronProp"> settings for neurons in feature maps </param> public PoolingLayer(FeatureMapsLayer fromLayer, Dimension2D kernelDim, int numberOfMaps, NeuronProperties neuronProp) { this.kernel = kernel; Dimension2D fromDimension = fromLayer.MapDimensions; int mapWidth = fromDimension.Width / kernel.Width; int mapHeight = fromDimension.Height / kernel.Height; this.mapDimensions = new Dimension2D(mapWidth, mapHeight); createFeatureMaps(numberOfMaps, mapDimensions, kernelDim, neuronProp); }
/// <summary> /// Equals /// </summary> /// <param name="obj">object</param> /// <returns></returns> public new bool Equals(object obj) { if (obj != null && obj is Dimension2D) { Dimension2D d = (Dimension2D)obj; if (d.getWidth() == width && d.getHeight() == height) { return(true); } } return(false); }
/// <summary> /// Creates pooling layer with specified kernel, appropriate map /// dimensions in regard to previous layer (fromLayer param) and specified /// number of feature maps with default neuron settings for pooling layer. /// Number of maps in pooling layer must be the same as number of maps in previous /// layer. /// </summary> /// <param name="fromLayer"> previous layer, which will be connected to this layer </param> /// <param name="kernel"> kernel for all feature maps </param> public PoolingLayer(FeatureMapsLayer fromLayer, Dimension2D kernelDim) { this.kernel = new Kernel(kernelDim); int numberOfMaps = fromLayer.NumberOfMaps; Dimension2D fromDimension = fromLayer.MapDimensions; int mapWidth = fromDimension.Width / kernel.Width; int mapHeight = fromDimension.Height / kernel.Height; this.mapDimensions = new Dimension2D(mapWidth, mapHeight); createFeatureMaps(numberOfMaps, mapDimensions, kernelDim, DEFAULT_NEURON_PROP); }
public WaterSceneNode(SceneNode parent, SceneManager mgr, Dimension2Df tileSize, Dimension2D tileCount, Dimension2D precision, int id) : base(parent, mgr, id) { _scene = mgr; _driver = mgr.VideoDriver; AnimatedMesh wmesh = _scene.AddHillPlaneMesh("watermesh" + _current, tileSize, tileCount, 0, new Dimension2Df(0, 0), new Dimension2Df(1, 1)); _current++; int dmat; if (_driver.DriverType == DriverType.OpenGL) dmat = _driver.GPUProgrammingServices.AddHighLevelShaderMaterial( WATER_VERTEX_GLSL, "main", VertexShaderType._1_1, WATER_FRAGMENT_GLSL, "main", PixelShaderType._1_1, OnShaderSet, MaterialType.TransparentAlphaChannel, 0); else dmat = _driver.GPUProgrammingServices.AddHighLevelShaderMaterial( WATER_HLSL, "vertexMain", VertexShaderType._2_0, WATER_HLSL, "pixelMain", PixelShaderType._2_0, OnShaderSet, MaterialType.TransparentAlphaChannel, 2); if (_driver.DriverType == DriverType.OpenGL) ClampShader = _driver.GPUProgrammingServices.AddHighLevelShaderMaterial( CLAMP_VERTEX_GLSL, "main", VertexShaderType._1_1, CLAMP_FRAGMENT_GLSL, "main", PixelShaderType._1_1, OnShaderSet, MaterialType.TransparentAlphaChannel, 1); else ClampShader = _driver.GPUProgrammingServices.AddHighLevelShaderMaterial( CLAMP_HLSL, "vertexMain", VertexShaderType._2_0, CLAMP_HLSL, "pixelMain", PixelShaderType._2_0, OnShaderSet, MaterialType.TransparentAlphaChannel, 3); _waternode = _scene.AddMeshSceneNode(wmesh.GetMesh(0), this, -1); _waternode.SetMaterialType(dmat); _waternode.SetMaterialFlag(MaterialFlag.BackFaceCulling, false); _waternode.SetMaterialFlag(MaterialFlag.Lighting, false); _waternode.SetMaterialFlag(MaterialFlag.FogEnable, false); _rt = _driver.CreateRenderTargetTexture(precision); _waternode.SetMaterialTexture(0, _rt); CameraSceneNode oldcam = _scene.ActiveCamera; _fixedcam = _scene.AddCameraSceneNode(null); if (oldcam != null) _scene.ActiveCamera = oldcam; }
public static void testLearningOneLayer() { Dimension2D inputDimension = new Dimension2D(5, 5); Dimension2D convolutionKernel = new Dimension2D(3, 3); ConvolutionalNetwork convolutionNet = (new ConvolutionalNetwork.Builder()).withInputLayer(5, 5, 1).withConvolutionLayer(3, 3, 2).withFullConnectedLayer(2).build(); // CREATE DATA SET DataSet dataSet = new DataSet(25, 2); dataSet.addRow(new double[] { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 }, new double[] { 1, 0 }); dataSet.addRow(new double[] { 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0 }, new double[] { 0, 1 }); // TRAIN NETWORK convolutionNet.LearningRule.MaxError = 0.00001; convolutionNet.learn(dataSet); Console.WriteLine("Done training!"); FeatureMapLayer featureMap1 = ((FeatureMapsLayer)convolutionNet.getLayerAt(1)).getFeatureMap(0); FeatureMapLayer featureMap2 = ((FeatureMapsLayer)convolutionNet.getLayerAt(1)).getFeatureMap(1); // WeightVisualiser visualiser1 = new WeightVisualiser(featureMap1, convolutionKernel); // visualiser1.displayWeights(); // // WeightVisualiser visualiser2 = new WeightVisualiser(featureMap2, convolutionKernel); // visualiser2.displayWeights(); // CREATE TEST SET DataSet testSet = new DataSet(25, 2); testSet.addRow(new double[] { 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 }, new double[] { 1, 0 }); testSet.addRow(new double[] { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0 }, new double[] { 1, 0 }); testSet.addRow(new double[] { 0, 1, 1, 1, 0, 0, 1, 1, 1, 0, 0, 1, 1, 1, 0, 0, 1, 1, 1, 0, 0, 1, 1, 1, 0 }, new double[] { 0, 1 }); }
/// <param name="args"> Command line parameters used to initialize parameters of convolutional network /// [0] - maximal number of epochs during learning /// [1] - learning error stop condition /// [2] - learning rate used during learning process /// [3] - number of feature maps in 1st convolutional layer /// [4] - number of feature maps in 2nd convolutional layer /// [5] - number of feature maps in 3rd convolutional layer </param> public static void Main(string[] args) { try { int maxIter = 10000; // Integer.parseInt(args[0]); double maxError = 0.01; //Double.parseDouble(args[1]); double learningRate = 0.2; // Double.parseDouble(args[2]); int layer1 = Convert.ToInt32(args[3]); int layer2 = Convert.ToInt32(args[4]); int layer3 = Convert.ToInt32(args[5]); LOG.info("{}-{}-{}", layer1, layer2, layer3); DataSet trainSet = MNISTDataSet.createFromFile(MNISTDataSet.TRAIN_LABEL_NAME, MNISTDataSet.TRAIN_IMAGE_NAME, 100); DataSet testSet = MNISTDataSet.createFromFile(MNISTDataSet.TEST_LABEL_NAME, MNISTDataSet.TEST_IMAGE_NAME, 10000); Dimension2D inputDimension = new Dimension2D(32, 32); Dimension2D convolutionKernel = new Dimension2D(5, 5); Dimension2D poolingKernel = new Dimension2D(2, 2); ConvolutionalNetwork convolutionNetwork = (new ConvolutionalNetwork.Builder()).withInputLayer(32, 32, 1).withConvolutionLayer(5, 5, layer1).withPoolingLayer(2, 2).withConvolutionLayer(5, 5, layer2).withPoolingLayer(2, 2).withConvolutionLayer(5, 5, layer3).withFullConnectedLayer(10).build(); ConvolutionalBackpropagation backPropagation = new ConvolutionalBackpropagation(); backPropagation.LearningRate = learningRate; backPropagation.MaxError = maxError; backPropagation.MaxIterations = maxIter; backPropagation.addListener(new LearningListener(convolutionNetwork, testSet)); backPropagation.ErrorFunction = new MeanSquaredError(); convolutionNetwork.LearningRule = backPropagation; convolutionNetwork.learn(trainSet); Evaluation.runFullEvaluation(convolutionNetwork, testSet); } catch (IOException e) { Console.WriteLine(e.ToString()); Console.Write(e.StackTrace); } }
protected internal override void OnRender(RenderEventArgs e) { e.Canvas.Color = Colors.Silver; // mvarBackgroundColor; e.Canvas.FillRectangle(0, 0, Size.Width, Size.Height); if (mvarPressed) { e.Canvas.DrawSunkenBorder(0, 0, Size.Width, Size.Height, 2); } else { e.Canvas.DrawRaisedBorder(0, 0, Size.Width, Size.Height, 2); } e.Canvas.Color = mvarForegroundColor; double x = 0, y = 0; Dimension2D dim = e.Canvas.MeasureText(base.Text); x = ((Size.Width - dim.Width) / 2); y = ((Size.Height - dim.Height) / 2) + 12; e.Canvas.DrawText(Text, x, y); }
public bool InitDevices(Control target_window) { _target_window = target_window; Dimension2D dim = new Dimension2D(target_window.Size.Width, target_window.Size.Height); _device = new IrrlichtDevice(DriverType.OpenGL, dim, 32, false, false, false, false, target_window.Handle); _device.Resizeable = true; //_device.OnEvent += new OnEventDelegate(_device_OnEvent); _scene = _device.SceneManager; _driver = _device.VideoDriver; return(true); }
public static void DrawLine(Color color, Position2D start, Dimension2D tSize) { OGLTools.glDisable(Gl.GL_TEXTURE_2D); OGLTools.glEnable(Gl.GL_ALPHA); Gl.glEnable(Gl.GL_BLEND); Gl.glBlendFunc(Gl.GL_SRC_ALPHA, Gl.GL_ONE_MINUS_SRC_ALPHA); Gl.glColor4f(1.0f, 1.0f, 1.0f, 1f); Gl.glPushMatrix(); Gl.glTranslated(start.X, start.Y, 0); float x1, y1; Gl.glBegin(Gl.GL_LINES); Gl.glColor3f(color.R / 255, color.G / 255, color.B / 255); Gl.glVertex2f(0f, 0f); Gl.glColor3f(color.R / 255, color.G / 255, color.B / 255); Gl.glVertex2f(tSize.Width, tSize.Height); Gl.glEnd(); // disable blending glDisable(Gl.GL_BLEND); OGLTools.glDisable(Gl.GL_ALPHA); Gl.glPopMatrix(); // Need to optimize this like glPopMatrix(sessionID); }
public FlattenedBitmap(int width, int height, int stride, byte[,] data) { Dimension = new Dimension2D(width, height); Stride = stride; Data = data; }
public static void DrawTexture(OGLTexture txt, Position2D texturePosition, Dimension2D textureSize, Position2D targetPosition, Dimension2D targetSize, float Alpha) { /*if ((targetPosition.X < 0) || (targetPosition.X >= oGL.Width)) return; if ((targetPosition.Y < 0) || (targetPosition.Y >= oGL.Height)) return; if ((targetPosition.X + targetSize.Width < 0) || (targetPosition.X + targetSize.Width >= oGL.Width)) return; if ((targetPosition.Y + targetSize.Height < 0) || (targetPosition.Y + targetSize.Height >= oGL.Height)) return;*/ glEnable2D(); glEnable(Gl.GL_ALPHA); OGLTools.glEnable(Gl.GL_TEXTURE_2D); Gl.glEnable(Gl.GL_BLEND); Gl.glBlendFunc(Gl.GL_SRC_ALPHA, Gl.GL_ONE_MINUS_SRC_ALPHA); Gl.glColor4f(1.0f, 1.0f, 1.0f, Alpha); Gl.glPushMatrix(); Gl.glTranslated(targetPosition.X, targetPosition.Y, 0); if (m_CurrentTextureID != (int)txt.TextureId) { m_CurrentTextureID = (int)txt.TextureId; Gl.glBindTexture(Gl.GL_TEXTURE_2D, m_CurrentTextureID); } float x1, y1; Gl.glBegin(Gl.GL_QUADS); // Extract bottom left position //x1 = (1.0f / (float)txt.Size.Width * (float)texturePosition.X) - txt.Size.GetFloatingX(textureSize.Width - txt.Size.Width); //y1 = (1.0f / (float)txt.Size.Height * (float)texturePosition.Y) - txt.Size.GetFloatingY(textureSize.Width - txt.Size.Height); x1 = 1 / (float)txt.Size.Width * (float)texturePosition.X; y1 = 1 / (float)txt.Size.Height * (float)texturePosition.Y; Gl.glTexCoord2f(x1, y1 * -1); Gl.glVertex2i(0, 0); // Extract bottom right //x1 = (1.0f / (float)txt.Size.Width * (float)texturePosition.X) - txt.Size.GetFloatingX(textureSize.Width); //y1 = (1.0f / (float)txt.Size.Height * (float)texturePosition.Y) - txt.Size.GetFloatingY(textureSize.Height - txt.Size.Height); x1 = 1 / (float)txt.Size.Width * ((float)texturePosition.X + (float)textureSize.Width); y1 = 1 / (float)txt.Size.Height * (float)texturePosition.Y; Gl.glTexCoord2f(x1, y1 * -1); Gl.glVertex2i(targetSize.Width, 0); // Extract top right //x1 = (1.0f / (float)txt.Size.Width * (float)texturePosition.X) - txt.Size.GetFloatingX(textureSize.Width); //y1 = (1.0f / (float)txt.Size.Height * (float)texturePosition.Y) - txt.Size.GetFloatingY(textureSize.Height); x1 = 1 / (float)txt.Size.Width * ((float)texturePosition.X + (float)textureSize.Width); y1 = 1 / (float)txt.Size.Height * ((float)texturePosition.Y + (float)textureSize.Height); Gl.glTexCoord2f(x1, y1 * -1); Gl.glVertex2i(targetSize.Width, targetSize.Height); // Extract top left position //x1 = (1.0f / (float)txt.Size.Width * (float)texturePosition.X) - txt.Size.GetFloatingX(textureSize.Width - txt.Size.Width); //y1 = (1.0f / (float)txt.Size.Height * (float)texturePosition.Y) - txt.Size.GetFloatingY(textureSize.Height); x1 = 1 / (float)txt.Size.Width * (float)texturePosition.X; y1 = 1 / (float)txt.Size.Height * ((float)texturePosition.Y + (float)textureSize.Height); Gl.glTexCoord2f(x1, y1 * -1); Gl.glVertex2i(0, targetSize.Height + 0); Gl.glEnd(); // disable blending glDisable(Gl.GL_BLEND); Gl.glPopMatrix(); // Need to optimize this like glPopMatrix(sessionID); }
/// <summary> /// Creates an empty 2D layer with specified dimensions and kernel /// </summary> /// <param name="dimensions"> layer dimensions (width and weight) </param> public FeatureMapLayer(Dimension2D dimensions, Dimension2D kernelDimension) { this.dimensions = dimensions; this.kernel = new Kernel(kernelDimension); }
public static void DrawFilledRectangle(Color color, Position2D start, Dimension2D size) { OGLTools.glDisable(Gl.GL_TEXTURE_2D); OGLTools.glEnable(Gl.GL_ALPHA); Gl.glEnable(Gl.GL_BLEND); Gl.glBlendFunc(Gl.GL_SRC_ALPHA, Gl.GL_ONE_MINUS_SRC_ALPHA); Gl.glColor4f(1.0f, 1.0f, 1.0f, 1f); Gl.glPushMatrix(); Gl.glTranslated(start.X, start.Y, 0); float x1, y1; /* Gl.glBegin(Gl.GL_QUADS); Gl.glColor3f((float)color.R / 255f, (float)color.G / 255f, (float)color.B / 255f); Gl.glVertex2f(0f, 0f); Gl.glVertex2f(0, size.Height); Gl.glVertex2f(size.Width, size.Height); Gl.glVertex2f(size.Width, 0); Gl.glVertex2f(0f, 0f); Gl.glEnd(); */ float[] Vertices = new float[] { 0, 0, 0, (float)size.Height, (float)size.Width, (float)size.Height, (float)size.Width, 0, 0, 0 }; float[] Indices = { 0, 1, 2, 3, 4 }; //Load the arrays Gl.glColor3f((float)color.R / 255f, (float)color.G / 255f, (float)color.B / 255f); Gl.glEnableClientState(Gl.GL_VERTEX_ARRAY); Gl.glVertexPointer(2, Gl.GL_FLOAT, 0, Vertices); Gl.glDrawArrays(Gl.GL_QUADS, 0, Indices.Length); Gl.glDisableClientState(Gl.GL_VERTEX_ARRAY); // disable blending glDisable(Gl.GL_BLEND); OGLTools.glDisable(Gl.GL_ALPHA); Gl.glPopMatrix(); // Need to optimize this like glPopMatrix(sessionID); }
public static void DrawTexture(OGLTexture txt, Position2D texturePosition, Dimension2D textureSize, Position2D srcPosition, Position2D targetPosition, float Alpha) { Dimension2D tSize = new Dimension2D(targetPosition.X - srcPosition.X, targetPosition.Y - srcPosition.Y); DrawTexture(txt, texturePosition, textureSize, srcPosition, tSize, Alpha); }
public void SetControlMinimumSize(Control ctl, Dimension2D minimumSize) { mvarMinimumSizes[ctl] = minimumSize; }
/// <summary> /// Creates a new empty feature maps layer with specified kernel and /// feature map dimensions. /// </summary> /// <param name="kernel"> kernel used for all feature maps in this layer </param> /// <param name="mapDimensions"> mapDimensions of feature maps in this layer </param> public FeatureMapsLayer(Dimension2D mapDimensions) //Kernel kernel, { // this.kernel = kernel; this.mapDimensions = mapDimensions; this.featureMaps = new List <FeatureMapLayer>(); }
//xy should be the normalized coordinates in UV space, this function then returns the UV coordinates in pixel coordinates Vector2 DecodeUV(Vector2 xy) { Texture t = _renderer.sharedMaterial.GetTexture("_MainTex"); Dimension2D wh = new Dimension2D(t.width,t.height); return new Vector2(xy.x * wh.width, xy.y * wh.height); }
public Rect(Position2D pos, Dimension2D size) { UpperLeftCorner = new Position2D(); LowerRightCorner = new Position2D(); Set(pos, size); }
//accepts the pixel coordinates of the Vector2 CalcUV(Vector2 xy) { Texture t = _renderer.sharedMaterial.GetTexture("_MainTex"); Dimension2D wh = new Dimension2D(t.width,t.height); return new Vector2(xy.x / wh.width, (wh.height - xy.y) / wh.height); }
void Awake() { CacheComponents(); _dimensions = new Vector2(_meshFilter.mesh.bounds.size.x, _meshFilter.mesh.bounds.size.y); }
public void Set(Position2D pos, Dimension2D size) { UpperLeftCorner = pos; LowerRightCorner = new Position2D(pos.X + size.Width, pos.Y + size.Height); }
/// <summary> /// Create InputMapsLayer with specified number of maps with specified dimensions </summary> /// <param name="mapDimension"> dimensions of a single feature map </param> /// <param name="mapCount"> number of feature maps </param> public InputMapsLayer(Dimension2D mapDimensions, int mapCount) : base(mapDimensions, mapCount, InputMapsLayer.DEFAULT_NEURON_PROP) { }
public Dimension2D GetDimensionsForResizeBeforeCentering(Dimension2D inputSizeAsMultiplesOfFour) { return(new Dimension2D( (int)Math.Ceiling(inputSizeAsMultiplesOfFour.Width / ((double)inputSizeAsMultiplesOfFour.Height / ExpectedSize2D.Height)), ExpectedSize2D.Height)); }
public WaterSceneNode(SceneNode parent, SceneManager mgr, Dimension2Df tileSize, Dimension2D tileCount) : this(parent, mgr, tileSize, tileCount, new Dimension2D(256, 256), -1) { }
public WaterSceneNode(SceneNode parent, SceneManager mgr, Dimension2Df tileSize, Dimension2D tileCount, Dimension2D precision) : this(parent, mgr, tileSize, tileCount, precision, -1) { }