コード例 #1
0
        public BitmapSource Render(RenderSourceType render_source)
        {
            IImageRaster <IRaster2DInteger, ElementValueType> rendered_image = inner_renderer.Render(render_source);
            BitmapFast bitmap_fast = new BitmapFast(rendered_image.Raster.Size0, rendered_image.Raster.Size1);

            bitmap_fast.Lock();
            for (int y_index = 0; y_index < rendered_image.Raster.Size1; y_index++)
            {
                for (int x_index = 0; x_index < rendered_image.Raster.Size0; x_index++)
                {
                    bitmap_fast.SetPixel(x_index, y_index, converter.Compute(rendered_image.GetElementValue(rendered_image.Raster.GetElementIndex(x_index, y_index))));
                }
            }
            bitmap_fast.Unlock();
            return(ToolsRendering.CreateBitmapSourceFromBitmap(bitmap_fast.Bitmap));
        }
コード例 #2
0
        public BitmapFast Render(RenderSourceType render_source)
        {
            IImageRaster <IRaster2DInteger, ElementValueType> rendered_image = inner_renderer.Render(render_source);
            BitmapFast bitmap_fast = new BitmapFast(rendered_image.Raster.Size0, rendered_image.Raster.Size1);

            bitmap_fast.Lock();
            //for (int y_index = 0; y_index < rendered_image.Raster.SizeY; y_index++)
            //{
            Parallel.For(0, rendered_image.Raster.Size1, y_index =>
            {
                for (int x_index = 0; x_index < rendered_image.Raster.Size0; x_index++)
                {
                    bitmap_fast.SetPixel(x_index, y_index, converter.Compute(rendered_image.GetElementValue(rendered_image.Raster.GetElementIndex(x_index, y_index))));
                }
            });
            bitmap_fast.Unlock();
            return(bitmap_fast);
        }
コード例 #3
0
        public void Render(BitmapFast bitmap_fast, Tuple <IImageRaster2D <bool>, IImageRaster2D <Color> > render_image)
        {
            IImageRaster2D <bool>  mask  = render_image.Item1;
            IImageRaster2D <Color> color = render_image.Item2;

            bitmap_fast.Lock();
            for (int y_index = 0; y_index < bitmap_fast.Height; y_index++)
            {
                for (int x_index = 0; x_index < bitmap_fast.Width; x_index++)
                {
                    if (mask.GetElementValue(x_index, y_index))
                    {
                        bitmap_fast.SetPixel(x_index, y_index, color.GetElementValue(x_index, y_index));
                    }
                }
            }
            bitmap_fast.Unlock();
        }
コード例 #4
0
        public BitmapFast Render(Tuple <double[][], Color[]> render_image)
        {
            double[][]  points           = render_image.Item1;
            Color[]     colors           = render_image.Item2;
            double [][] projected_points = new double [points.Length][];
            int[]       coordinates      = new int[3];

            for (int point_index = 0; point_index < points.Length; point_index++)
            {
                projected_points[point_index] = (projection_matrix * (points[point_index] - offset_matrix)).ToArray1DFloat64();
            }



            Raster2DInteger bitmap_raster     = new Raster2DInteger(bitmap_size_x, bitmap_size_y);
            BitmapFast      destination_image = new BitmapFast(this.bitmap_size_x, this.bitmap_size_y);

            destination_image.Lock();
            for (int index_y = 0; index_y < bitmap_raster.Size1; index_y++)
            {
                for (int index_x = 0; index_x < bitmap_raster.Size0; index_x++)
                {
                    destination_image.SetPixel(index_x, index_y, Color.Black);
                }
            }


            for (int element_index = 0; element_index < points.Length; element_index++)
            {
                int x_target = (int)(projected_points[element_index][0] * this.scale) + (bitmap_raster.Size0 / 2);
                int y_target = (int)(projected_points[element_index][1] * this.scale) + (bitmap_raster.Size1 / 2);

                if (bitmap_raster.ContainsCoordinates(x_target, y_target))
                {
                    destination_image.SetPixel(x_target, y_target, colors[element_index]);
                }
            }

            destination_image.Unlock();
            return(destination_image);
        }
コード例 #5
0
        private static void ProccessDataSetNominalPCA(IDataSet <int, int> training_set, IDataSet <int, int> test_set)
        {
            int cluster_count  = 10;
            int instance_count = training_set.InstanceCount;
            ITemplateClusteringCentroid <int, IDataSet <int> > template_cluster = new TemplateClusteringKMeansNominal(cluster_count);
            TemplateDimensionReductionPCADefault template_pca = new TemplateDimensionReductionPCADefault(3);
            IDataSet <int> training_set_unlabeled             = training_set;


            IClusteringCentroid <int> clustering = template_cluster.Cluster(training_set_unlabeled);

            double[][] transformed_data1 = new double[instance_count][];
            for (int instance_index = 0; instance_index < instance_count; instance_index++)
            {
                transformed_data1[instance_index] = clustering.Transform(training_set_unlabeled.GetInstanceFeatureData(instance_index));
            }


            IDataSet <double> data_set_transformed1 = new DataSet <double, int>(transformed_data1);


            ITransform transform = template_pca.GenerateTransform(data_set_transformed1);

            double[][] transformed_data2 = new double[instance_count][];
            int[][]    label_data        = training_set.LabelData;
            Color[]    instance_colors   = new Color[instance_count];
            Color[]    label_colors      = ToolsColor.GetPallete(training_set.DataContext.GetLabelDescriptor(0).ValueCount);

            for (int instance_index = 0; instance_index < instance_count; instance_index++)
            {
                transformed_data2[instance_index] = transform.TransformForward(data_set_transformed1.GetInstanceFeatureData(instance_index));
                instance_colors[instance_index]   = label_colors[label_data[instance_index][0]];
            }
            RendererPoints <Matrix <double> > renderer = new RendererPoints <Matrix <double> >(new AlgebraLinearReal64MathNet(), 1000, 1000, (AngleRadian)0, (AngleRadian)0, 10);
            BitmapFast bitmap = renderer.Render(new Tuple <double[][], Color[]>(transformed_data2, instance_colors));

            bitmap.Bitmap.Save("test.png");
        }