示例#1
0
        /// <summary>
        /// Set of lines in 3D space.
        /// </summary>
        /// <param name="origin"></param>
        /// <param name="xAxis"></param>
        /// <param name="yAxis"></param>
        /// <param name="scale">Scaling the field extent.</param>
        /// <param name="field"></param>
        public LineBall(Plane plane, LineSet lines, RenderEffect effect = RenderEffect.DEFAULT, Colormap colormap = Colormap.Parula, bool flatten = false)
        {
            _thickness = lines.Thickness * plane.PointSize;
            _color = lines.Color;
            this._vertexSizeBytes = Marshal.SizeOf(typeof(Vector4));
            this._numVertices = lines.NumPoints * 2 - lines.Lines.Length * 2; // Linelist means, all points are there twice, minus the endpoints.
            if (_numVertices == 0)
                return;
            this._topology = PrimitiveTopology.LineList;

            // Setting up the vertex buffer.
            if (!flatten)
                GenerateGeometry(plane, lines);
            else
                GenerateGeometryFlatXY(plane, lines);

            //this._technique = _lineEffect.GetTechniqueByName("Render");
            UsedMap = colormap;
            _planeNormal = plane.ZAxis;
            _planeNormal.Normalize();
            _effect = _lineEffect;
            SetRenderEffect(effect);

            this._vertexLayout = new InputLayout(_device, _technique.GetPassByIndex(0).Description.Signature, new[] {
                new InputElement("POSITION", 0, Format.R32G32B32_Float, 0, 0),
                new InputElement("SCALAR", 0, Format.R32_Float, 12, 0)
            });
        }
示例#2
0
        /// <summary>
        /// Plane to display scalar/vector field data on. Condition: Fields domain is 2D.
        /// </summary>
        /// <param name="origin"></param>
        /// <param name="xAxis"></param>
        /// <param name="yAxis"></param>
        /// <param name="scale">Scaling the field extent.</param>
        /// <param name="field"></param>
        public FieldPlane(Plane plane, VectorField fields, RenderEffect effect = RenderEffect.DEFAULT, Colormap map = Colormap.Parula)
        {
            #if DEBUG
            // Assert that the fields are 2 dimensional.
            foreach(Field field in fields.Scalars)
                System.Diagnostics.Debug.Assert(field.Size.Length >= 2);
            #endif
            this._effect = _planeEffect;
            this._vertexSizeBytes = 32;
            this._numVertices = 6;
            this.UsedMap = map;
            this._width  = fields[0].Size[0];
            this._height = fields[0].Size[1];
            this._invalid = fields.InvalidValue ?? float.MaxValue;
            this._field = fields;

            // Setting up the vertex buffer.
            GenerateGeometry(plane, fields[0].Size.ToInt2(), fields.TimeSlice??0);

            // Generating Textures from the fields.
            _fieldTextures = new ShaderResourceView[fields.Scalars.Length];
            for(int f = 0; f < _field.NumVectorDimensions; ++f)
            {
                Texture2D tex = ColorMapping.GenerateTextureFromField(_device, fields[f]);
                _fieldTextures[f] = new ShaderResourceView(_device, tex);
            }

            this.SetRenderEffect(effect);
            this._vertexLayout = new InputLayout(_device, _technique.GetPassByIndex(0).Description.Signature, new[] {
                new InputElement("POSITION", 0, Format.R32G32B32A32_Float, 0, 0),
                new InputElement("TEXTURE", 0, Format.R32G32B32A32_Float, 16, 0)
            });
        }
        public LineStatisticsMapper(VectorFieldUnsteady velocity, Plane plane)
            : base(plane, velocity.Size.ToInt2())
        {
            Velocity = velocity;
            Mapping = ComputeStatistics;
            Plane = plane;

            int time = velocity.Size.T;
        }
示例#4
0
 public CriticalPointTracking(CriticalPointSet2D[] cp, VectorFieldUnsteady velocity, Plane plane)
 {
     Debug.Assert(cp.Length == velocity.Size.T);
     CP = cp;
     Velocity = velocity;
     SlicesToRender = new VectorField[velocity.Size.T];
     for (int slice = 0; slice < velocity.Size.T; ++slice)
     {
         SlicesToRender[slice] = velocity.GetSlice(slice);
     }
     Mapping = TrackCP;
     Plane = plane;
 }
示例#5
0
        /// <summary>
        /// Set of points in 3D space.
        /// </summary>
        /// <param name="origin"></param>
        /// <param name="xAxis"></param>
        /// <param name="yAxis"></param>
        /// <param name="scale">Scaling the field extent.</param>
        /// <param name="field"></param>
        public PointCloud(Plane plane, PointSet<Point> points)
        {
            this._vertexSizeBytes = 32;
            this._numVertices = points.Points.Length;
            if (_numVertices == 0)
                return;
            this._topology = PrimitiveTopology.PointList;

            // Setting up the vertex buffer.
            GenerateGeometry(plane, points);

            Debug.Assert(_cloudEffect != null);
            this._technique = _cloudEffect.GetTechniqueByName("Render");
            this._vertexLayout = new InputLayout(_device, _technique.GetPassByIndex(0).Description.Signature, new[] {
                new InputElement("POSITION", 0, Format.R32G32B32A32_Float, 0, 0),
                new InputElement("COLOR", 0, Format.R32G32B32_Float, 16, 0),
                new InputElement("RADIUS", 0, Format.R32_Float, 28, 0)
            });
        }
示例#6
0
        //private Buffer _indices;
        /// <summary>
        /// Set of lines in 3D space.
        /// </summary>
        /// <param name="origin"></param>
        /// <param name="xAxis"></param>
        /// <param name="yAxis"></param>
        /// <param name="scale">Scaling the field extent.</param>
        /// <param name="field"></param>
        public Mesh(Plane plane, TileSurface surf, RenderEffect effect = RenderEffect.DEFAULT, Colormap colormap = Colormap.Parula)
        {
            _color = surf.Color;
            this._vertexSizeBytes = Marshal.SizeOf(typeof(Vector4));
            this._topology = PrimitiveTopology.TriangleList;
            this.
            // Setting up the vertex buffer.

            UsedMap = colormap;
            _planeNormal = plane.ZAxis;
            _planeNormal.Normalize();
            _effect = _meshEffect;
            SetRenderEffect(effect);

            GenerateGeometry(plane, surf);

            this._vertexLayout = new InputLayout(_device, _technique.GetPassByIndex(0).Description.Signature, new[] {
                new InputElement("POSITION", 0, Format.R32G32B32_Float, 0, 0),
                new InputElement("SCALAR", 0, Format.R32_Float, 12, 0)
            });
        }
        public PathlineLengthMapper(VectorFieldUnsteady velocity, Plane plane)
            : base(plane, velocity.Size.ToInt2())
        {
            Velocity = velocity;

            Mapping = ShowPaths;
            Plane = plane;

            int time = velocity.Size.T;
            _intersectTimeSlices = new PointSet<EndPoint>[time];
            _pathlineSegments = new LineSet[time - 1];
            _intersectTimeSlices[0] = FieldAnalysis.ValidDataPoints<EndPoint>(velocity.GetTimeSlice(0));//FieldAnalysis.SomePoints2D<EndPoint>(velocity, 100);//
            _points = new PointCloud[velocity.Size.T];
            _points[0] = new PointCloud(Plane, _intersectTimeSlices[0].ToBasicSet());
            _fieldPositionOfValidCell = new int[_intersectTimeSlices[0].Length];
            for(int i = 0; i < _fieldPositionOfValidCell.Length; ++i)
            {
                Vector3 pos = _intersectTimeSlices[0].Points[i].Position;
                _fieldPositionOfValidCell[i] = (int)(pos.X + 0.5) + (int)(pos.Y + 0.5) * Velocity.Size[0];
            }
        }
示例#8
0
        public FieldPlane(Plane plane, Texture2D field, Int2 texSize, float timeSlice = 0, float invalidValue = float.MaxValue, RenderEffect effect = RenderEffect.DEFAULT, Colormap map = Colormap.Parula)
        {
            this._effect = _planeEffect;
            this._vertexSizeBytes = 32;
            this._numVertices = 6;
            this.UsedMap = map;
            this._width = texSize.X;
            this._height = texSize.Y;
            this._invalid = invalidValue;

            // Setting up the vertex buffer.
            GenerateGeometry(plane, texSize, timeSlice);

            // Generating Textures from the fields.
            _fieldTextures = new ShaderResourceView[1];
            _fieldTextures[0] = new ShaderResourceView(_device, field);

            this.SetRenderEffect(effect);
            this._vertexLayout = new InputLayout(_device, _technique.GetPassByIndex(0).Description.Signature, new[] {
                new InputElement("POSITION", 0, Format.R32G32B32A32_Float, 0, 0),
                new InputElement("TEXTURE", 0, Format.R32G32B32A32_Float, 16, 0)
            });
        }
示例#9
0
        public PlaygroundMapper(Plane plane)
            : base(new Plane(plane, 1), new Int2(NUM_CELLS))
        {
            Mapping = Map;
            _velocity = Tests.CreateBowl(new Vec2(NUM_CELLS/2, 0), NUM_CELLS, new Vec2(-10, 0), 22, 200);
            _selections = new List<LineBall>(10);
            _selectionsAngle = new List<LineBall>(10);
            _steadySelection = new List<LineBall>(10);

            // Core.
            _core = new Line() { Positions = new Vector3[] { new Vector3(50, 100, 0), new Vector3(155, 100, _velocity.Size.T-1) } };
            LineSet set = new LineSet(new Line[] { _core }) { Color = new Vector3(0.2f) };
            set.Thickness *= 3;
            _coreBall = new LineBall(plane, set, LineBall.RenderEffect.DEFAULT);

            // Straight core.
            set = new LineSet(new Line[] { new Line() { Positions = new Vector3[] { _core[0], _core[0] + Vector3.UnitZ * (_velocity.Size.T - 1) } } }) { Color = new Vector3(0.2f) };
            set.Thickness *= 3;
            _straightCoreBall = new LineBall(Plane, set);

            var center = Tests.CreatePerfect(new Vec2(0, 0), NUM_CELLS, new Vec2(0), 1, 200);
            _steadyField = center.GetTimeSlice(0); //[0] as ScalarField;
        }
示例#10
0
 public SubstepViewer(Plane plane)
 {
     //_ranges = ranges;
     _fields = new FieldPlane[1];
     Plane = plane;
     Mapping = LoadMembers;
 }
示例#11
0
        public override void EndSelection(Vector2[] points)
        {
            base.EndSelection(points);
            // When currently a subrange is selected, switch to full range on click.
            if (_subrange)
            {
                _startPoint += _minPlane;
                _algorithm.CompleteRange(_startPoint);
                _subrangePlane = Plane;
            }
            // Select subrange.
            else
            {
                Vector2 minV = new Vector2(
                    Math.Min(points[0].X, points[1].X),
                    Math.Min(points[0].Y, points[1].Y));

                // Int2 values.
                Int2 min = (Int2)minV;
                Vector2 maxV = points[0] + points[1] - minV;
                Int2 max = (Int2)maxV;

                min = Int2.Max(min, new Int2(0)).AsInt2();
                min = Int2.Min(min, _globalMaxPlane).AsInt2();

                max = Int2.Min(max, _globalMaxPlane).AsInt2();
                max = Int2.Max((Int2)max, new Int2(0)).AsInt2();

                if (min.X - max.X == 0 || min.Y - max.Y == 0)
                {
                    return;
                }

                _startPoint = _startPoint - min;

                if (!_startPoint.IsPositive() || _startPoint > max - min)
                    _startPoint = (max - min) / 2;

                _algorithm.Subrange(min, max - min, _startPoint);
                _subrangePlane = new Plane(Plane, new Vector3(min.X, min.Y, 0));
                _minPlane = min;
                _maxPlane = max;
            }

            _subrange = !_subrange;
        }
示例#12
0
 public SelectionMapper(Plane plane, Int2 fieldSize2D)
 {
     Plane = plane;
     _subrangePlane = Plane;
     _maxPlane = fieldSize2D;
     _globalMaxPlane = fieldSize2D;
 }
示例#13
0
        public List<Renderable> AdvectLines()
        {
            List<Renderable> renderables = new List<Renderable>(3 + _currentSetting.LineX);
            int numLines = _currentSetting.LineX;

            // Update / create underlying plane.
            if (_lastSetting == null ||
                SliceTimeMainChanged)
            {
                _timeSlice = new FieldPlane(Plane, _velocity.GetTimeSlice(_currentSetting.SliceTimeMain), _currentSetting.Shader, _currentSetting.Colormap);
                _intersectionPlane = new Plane(_intersectionPlane, new Vector3(0, 0, _currentSetting.SliceTimeMain - (_lastSetting?.SliceTimeMain) ?? 0));
            }
            else if (ColormapChanged ||
                ShaderChanged)
            {
                _timeSlice.SetRenderEffect(_currentSetting.Shader);
                _timeSlice.UsedMap = _currentSetting.Colormap;
            }
            // First item in list: plane.
            renderables.Add(_timeSlice);

            // Add Point to indicate clicked position.
            renderables.Add(new PointCloud(Plane, new PointSet<Point>(new Point[] { new Point() { Position = new Vector3(_selection, _currentSetting.SliceTimeMain + _velocity.Grid.TimeOrigin ?? 0), Color = new Vector3(1, 0, 1), Radius = 0.5f } })));
            bool rebuilt = false;

            // Recompute lines if necessary.
            if (_lastSetting == null ||
                LineXChanged ||
                AlphaStableChanged ||
                StepSizeChanged ||
                IntegrationTypeChanged ||
                IntegrationTimeChanged ||
                FlatChanged ||
                _selectionChanged)
            {
                if (_velocity.IsValid((Vec2)_selection))
                {
                    // Compute starting positions.
                    Point[] circle = new Point[numLines];
                    float offset = _currentSetting.AlphaStable;
                    float angleDiff = 2 * (float)(Math.PI / numLines);
                    for (int dir = 0; dir < numLines; ++dir)
                    {
                        float x = (float)(Math.Sin(angleDiff * dir + Math.PI / 2));
                        float y = (float)(Math.Cos(angleDiff * dir + Math.PI / 2));
                        circle[dir] = new Point() { Position = new Vector3(_selection.X + x * offset, _selection.Y + y * offset, _currentSetting.SliceTimeMain + (_velocity.Grid.TimeOrigin ?? 0)) };
                    }

                    VectorField.Integrator integrator = VectorField.Integrator.CreateIntegrator(_velocity, _currentSetting.IntegrationType);
                    integrator.StepSize = _currentSetting.StepSize;
                    //bool pos = _velocity.SampleDerivative(new Vec3((Vec2)_selection, _currentSetting.SliceTimeMain)).EigenvaluesReal()[0] > 0;
                    //integrator.Direction = pos ? Sign.POSITIVE : Sign.NEGATIVE;

                    LineSet[] lineSets = integrator.Integrate<Point>(new PointSet<Point>(circle), true); /*, _currentSetting.AlphaStable * 10);
                    PointSet<EndPoint> ends = lineSets[0].GetEndPoints();
                    lineSets[0] = integrator.Integrate(ends, false)[0];
                    ends = lineSets[1].GetEndPoints();
                    lineSets[1] = integrator.Integrate(ends, false)[0];*/

                    // COmpute and show statistics.
                    if (_currentSetting.Flat)
                    {
                        lineSets[0].FlattenLines(_currentSetting.SliceTimeMain);
                        lineSets[1].FlattenLines(_currentSetting.SliceTimeMain);
                        _graph = new Renderable[0];
                        // Compute values (distance to start point).
                        foreach (LineSet lines in lineSets)
                        {
                            Line[] starLines = new Line[lines.Lines.Length];

                            int count = 0;
                            float[] values = new float[lines.NumExistentPoints];

                            for (int l = 0; l < lines.Lines.Length; ++l)
                            {
                                Line line = lines.Lines[l];
                                // Outgoing direction.
                                Vector3 start = line.Positions[0];
                                Vector3 dir = line.Positions[0] - new Vector3(_selection, line.Positions[0].Z); ; dir.Normalize();

                                // Scale such that step size does not scale.
                                dir *= _currentSetting.StepSize / _velocity.Size.T * 40;

                                // Write star coordinates here.
                                Vector3[] starPos = new Vector3[line.Length];

                                for (int p = 0; p < line.Length; ++p)
                                {
                                    values[count++] = new Vector2(line.Positions[p].X - _selection.X, line.Positions[p].Y - _selection.Y).Length();
                                    starPos[p] = start + p * dir;
                                }
                                starLines[l] = new Line() { Positions = starPos };
                            }
                            var graph = FieldAnalysis.BuildGraph(Plane, new LineSet(starLines), values, _currentSetting.IntegrationTime, _currentSetting.LineSetting, _currentSetting.Colormap);
                            _graph = graph.Concat(_graph).ToArray();
                        }
                    }
                    else
                        _graph = null;
                    _pathlines = new LineBall[] { new LineBall(Plane, lineSets[0]), new LineBall(Plane, lineSets[1]) };
                }
                _selectionChanged = false;
                rebuilt = true;
            }

            if (_graph != null &&
                _currentSetting.LineSetting == RedSea.DisplayLines.LINE && (
                _lastSetting == null || rebuilt ||
                WindowWidthChanged ||
                WindowStartChanged ||
                ColormapChanged))
            {
                foreach (Renderable ball in _graph)
                {
                    (ball as LineBall).LowerBound = _currentSetting.WindowStart + _currentSetting.AlphaStable * _currentSetting.IntegrationTime + _currentSetting.SliceTimeMain;
                    (ball as LineBall).UpperBound = _currentSetting.WindowStart + _currentSetting.AlphaStable * _currentSetting.IntegrationTime + _currentSetting.SliceTimeMain + _currentSetting.WindowWidth;
                    (ball as LineBall).UsedMap = _currentSetting.Colormap;
                }
            }

            // Add the lineball.
            if (_pathlines != null)
                renderables.AddRange(_pathlines);
            if (_graph != null && _currentSetting.Graph)
                renderables = renderables.Concat(_graph.ToList()).ToList();
            return renderables;
        }
示例#14
0
 public Plane(Plane cpy)
 {
     Origin = cpy.Origin;
     XAxis = cpy.XAxis;
     YAxis = cpy.YAxis;
     ZAxis = cpy.ZAxis;
     PointSize = cpy.PointSize;
 }
示例#15
0
 public ConcentricDistanceMapper(int everyNthField, Plane plane)
     : base(everyNthField, plane)
 {
     Mapping = Map;
 }
示例#16
0
        protected override void UpdateBoundary()
        {
            if (_lastSetting != null && (_rebuilt || FlatChanged || GraphChanged))
            {
                Graph2D[] dist = FieldAnalysis.GraphDifferenceForward(_distanceAngleGraph);
                Plane zPlane = new Plane(_graphPlane, Vector3.UnitZ * 2);
                _graph = new LineBall(_graphPlane, FieldAnalysis.WriteGraphToSun(_errorGraph, new Vector3(_selection.X, _selection.Y, 0)), LineBall.RenderEffect.HEIGHT, Colormap, Flat);
                //               _graph = new LineBall(zPlane, FieldAnalysis.WriteGraphsToCircles(dist, new Vector3(_selection.X, _selection.Y, SliceTimeMain)), LineBall.RenderEffect.HEIGHT, Colormap, false);
                _rebuilt = false;
            }
            if (_lastSetting != null && (IntegrationTimeChanged || _rebuilt || Graph && GraphChanged && Flat))
                BuildGraph();
            //_graph = new LineBall(_graphPlane, FieldAnalysis.WriteGraphToSun(_errorGraph, new Vector3(_selection.X, _selection.Y, 0)), LineBall.RenderEffect.HEIGHT, Colormap, false);
            // new LineBall(_graphPlane, FieldAnalysis.WriteGraphsToCircles(_distanceAngleGraph, new Vector3(_selection.X, _selection.Y, SliceTimeMain)), LineBall.RenderEffect.HEIGHT, Colormap, false);
            //LineSet cutLines;
            ////if (SliceTimeReference > SliceTimeMain)
            ////{
            ////    // _graph = cut version of _coreAngleGraph.
            ////    int length = SliceTimeReference - SliceTimeMain;
            ////    length = (int)((float)length / StepSize + 0.5f);
            ////    cutLines = FieldAnalysis.CutLength(new LineSet(_coreDistanceGraph), length);
            ////}
            ////else
            ////    cutLines = new LineSet(_coreDistanceGraph);

            //cutLines = new LineSet(FieldAnalysis.);

            //_graph = new LineBall[] { new LineBall(_graphPlane, cutLines, LineBall.RenderEffect.HEIGHT, Colormap) };
        }
示例#17
0
        /// <summary>
        /// Setting up the vertex buffer. Vertex size and number has to be known.
        /// </summary>
        /// <param name="origin"></param>
        /// <param name="xAxis"></param>
        /// <param name="yAxis"></param>
        /// <param name="scale"></param>
        protected void GenerateGeometry(Plane plane, Int2 size, float timeOffset)
        {
            SetToSubrange(plane, size, Vector3.Zero, (Vector3)(Vector)size, timeOffset);
            //Vector Extent = grid.Extent;
            //Vector3 maximum = plane.Origin + plane.XAxis * (Extent[0] + grid.Origin[0]) + plane.YAxis * (Extent[1] + grid.Origin[1]);
            //Vector3 origin = plane.Origin + plane.ZAxis * timeOffset + plane.XAxis * grid.Origin[0] + plane.YAxis * grid.Origin[1];

            //// Offset, becaue the grid data points shall be OUTSIDE of the grid cells.
            //float uMin = 1.0f / (grid.Size[0] - 1) * 0.5f;
            //float vMin = 1.0f / (grid.Size[1] - 1) * 0.5f;
            //float uMax = 1 - uMin;
            //float vMax = 1 - vMin;

            //// Write poition and UV-map data.
            //var stream = new DataStream(_numVertices * _vertexSizeBytes, true, true);
            //stream.WriteRange(new[] {
            //    new Vector4( origin[0], maximum[1], origin[2], 1.0f), new Vector4(uMin, vMax, 0.0f, 1.0f),
            //    new Vector4(maximum[0], maximum[1], origin[2], 1.0f), new Vector4(uMax, vMax, 0.0f, 1.0f),
            //    new Vector4(maximum[0],  origin[1], origin[2], 1.0f), new Vector4(uMax, vMin, 0.0f, 1.0f),

            //    new Vector4( origin[0], maximum[1], origin[2], 1.0f), new Vector4(uMin, vMax, 0.0f, 1.0f),
            //    new Vector4(maximum[0],  origin[1], origin[2], 1.0f), new Vector4(uMax, vMin, 0.0f, 1.0f),
            //    new Vector4( origin[0],  origin[1], origin[2], 1.0f), new Vector4(uMin, vMin, 0.0f, 1.0f)

            //});
            //stream.Position = 0;

            //// Create and fill buffer.
            //_vertices = new Buffer(_device, stream, new BufferDescription()
            //{
            //    BindFlags = BindFlags.VertexBuffer,
            //    CpuAccessFlags = CpuAccessFlags.None,
            //    OptionFlags = ResourceOptionFlags.None,
            //    SizeInBytes = _numVertices * _vertexSizeBytes,
            //    Usage = ResourceUsage.Default
            //});
            //stream.Dispose();
        }
示例#18
0
 public LocalDiffusionMapper(VectorFieldUnsteady velocity, Plane plane)
     : base(plane, velocity.Size.ToInt2())
 {
     _diffusionMap = new LocalDiffusion(velocity, 0, 0.3f);
     _algorithm = _diffusionMap;
      //           _ftleMap = new FTLE(velocity, 0, 0.3f);
     Plane = plane;
     _subrangePlane = Plane;
     Mapping = GetCurrentMap;
     _velocity = velocity;
     _maxPlane = velocity.Size.ToInt2();
 }
示例#19
0
 public FlowMapMapper(LoaderNCF.SliceRange[] uv, Plane plane, VectorFieldUnsteady velocity)
     : base(plane, velocity.Size.ToInt2())
 {
     _flowMap = new FlowMapUncertain(_startPoint, uv, 0, 9);
     _algorithm = _flowMap;
     Plane = plane;
     _subrangePlane = Plane;
     Mapping = GetCurrentMap;
     _velocity = velocity;
     _maxPlane = velocity.Size.ToInt2();
 }
示例#20
0
 public DiffusionMapper(VectorFieldUnsteady velocity, Plane plane)
     : base(plane, velocity.Size.ToInt2())
 {
     _diffusionMap = new CutDiffusion(velocity, 0, 0.3f);
     _algorithm = _diffusionMap;
     Plane = plane;
     _subrangePlane = Plane;
     Mapping = GetCurrentMap;
     _velocity = velocity;
     _maxPlane = velocity.Size.ToInt2();
     _scaledPlane = new Plane(_subrangePlane.Origin, _subrangePlane.XAxis, _subrangePlane.YAxis, _subrangePlane.ZAxis, 1.0f/_cellToSeedRatio, _subrangePlane.PointSize);
 }
示例#21
0
        public static void LoadData()
        {
            System.Globalization.CultureInfo customCulture = (System.Globalization.CultureInfo)System.Threading.Thread.CurrentThread.CurrentCulture.Clone();
            customCulture.NumberFormat.NumberDecimalSeparator = ".";

            System.Threading.Thread.CurrentThread.CurrentCulture = customCulture;

            Console.WriteLine("Output works.");
            Console.WriteLine("Using " + (Environment.Is64BitProcess ? "x64" : "x32"));
            bool loadData = true;

            int numTimeSlices = 60;
            RedSea.Singleton.NumTimeSlices = numTimeSlices;
            //string locDataFolder = "E:/Anke/Dev/Data/Shaheen_8/s"; //"E:/Anke/Dev/Data/First/s";
            //string locFileName = "/Posterior_Diag.nc";
            //string locFolderName = "/advance_temp";
            //string locWFileName = ".0000000108.data";

            RedSea.Singleton.GetLoader = RedSeaLoader; //= (step, substep, var) => locDataFolder + (step + 1) + ((substep == null)?(var == RedSea.Variable.VELOCITY_Z? "/W" + locWFileName : locFileName) : (locFolderName + substep) + "/" + "S" + locWFileName);
            RedSea.Singleton.GetFilename = RedSeaFilenames;
            RedSea.Singleton.DonutFileName = "C:/Users/anke/Documents/VIS/Eddy/Results/Donut";
            RedSea.Singleton.CoreFileName = "C:/Users/anke/Documents/VIS/Eddy/Results/Core";
            RedSea.Singleton.SnapFileName = "C:/Users/anke/Documents/VIS/Eddy/Results/Screenshots/";
            RedSea.Singleton.RingFileName = "C:/Users/anke/Documents/VIS/Eddy/Results/Rings/";
            //Tests.CopyBeginningOfFile(RedSea.Singleton.GetFilename(0), 100000);

            //LoaderNCF ncFile = RedSea.Singleton.GetLoaderNCF(0);
            //ScalarField[] u = new ScalarField[numTimeSlices];
            //LoaderNCF.SliceRange sliceU = new LoaderNCF.SliceRange(ncFile, RedSea.Variable.VELOCITY_X);
            //sliceU.SetMember(RedSea.Dimension.MEMBER, 0); // Average
            //sliceU.SetMember(RedSea.Dimension.TIME, 0);
            //sliceU.SetMember(RedSea.Dimension.CENTER_Z, 0);
            ////sliceU.SetRange(RedSea.Dimension.GRID_X, 300, 100);
            ////sliceU.SetRange(RedSea.Dimension.CENTER_Y, 20, 100);

            //ScalarField[] v = new ScalarField[numTimeSlices];
            //LoaderNCF.SliceRange sliceV = new LoaderNCF.SliceRange(ncFile, RedSea.Variable.VELOCITY_Y);
            //sliceV.SetMember(RedSea.Dimension.MEMBER, 0);
            //sliceV.SetMember(RedSea.Dimension.TIME, 0);
            //sliceV.SetMember(RedSea.Dimension.CENTER_Z, 0);
            ////sliceV.SetRange(RedSea.Dimension.CENTER_X, 300, 100);
            ////sliceV.SetRange(RedSea.Dimension.GRID_Y, 20, 100);

            //ensembleU = new LoaderNCF.SliceRange(ncFile, RedSea.Variable.VELOCITY_X);
            //ensembleU.SetMember(RedSea.Dimension.TIME, 0);
            //ensembleU.SetMember(RedSea.Dimension.CENTER_Z, 0);
            //ensembleU.SetRange(RedSea.Dimension.MEMBER, 2, 50);
            ////ensembleU.SetRange(RedSea.Dimension.GRID_X, 100, 160);
            ////ensembleU.SetRange(RedSea.Dimension.CENTER_Y, 10, 70);
            //ensembleV = new LoaderNCF.SliceRange(ncFile, RedSea.Variable.VELOCITY_Y);
            //ensembleV.SetMember(RedSea.Dimension.TIME, 0);
            //ensembleV.SetMember(RedSea.Dimension.CENTER_Z, 0);
            //ensembleV.SetRange(RedSea.Dimension.MEMBER, 2, 50);
            ////ensembleV.SetRange(RedSea.Dimension.CENTER_X, 100, 160);
            ////ensembleV.SetRange(RedSea.Dimension.GRID_Y, 10, 70);

            Loader.SliceRange rawU = new LoaderRaw.SliceRangeRaw(RedSea.Variable.VELOCITY_X);
            rawU.SetMember(RedSea.Dimension.GRID_Z, 0);
            rawU.SetMember(RedSea.Dimension.MEMBER, 0);
            rawU.SetMember(RedSea.Dimension.SUBTIME, 0);
            Loader.SliceRange rawV = new LoaderRaw.SliceRangeRaw(RedSea.Variable.VELOCITY_Y);
            rawV.SetMember(RedSea.Dimension.GRID_Z, 0);
            rawV.SetMember(RedSea.Dimension.MEMBER, 0);
            rawV.SetMember(RedSea.Dimension.SUBTIME, 0);

            //rawU.SetMember(RedSea.Dimension.TIME, 40);

            //rawV.SetMember(RedSea.Dimension.TIME, 40);
            //ncFile.Close();

            //if (loadData)
            //{
            //    //velocity = LoaderRaw.LoadTimeSeries(new Loader.SliceRange[] { sliceU, sliceV }, 0, numTimeSlices);
            //    velocity = LoaderRaw.LoadTimeSeries(new Loader.SliceRange[] { rawU, rawV });

            //    // Scale the field from m/s to (0.1 degree per 3 days).
            //    velocity.ScaleToGrid(new Vec2(RedSea.Singleton.TimeScale));
            //}
            //else
            //{
            //    velocity = Tests.CreateCircle(new Vec2(0), 100, new Vec2(0/*.2f*/), numTimeSlices, 8);
            //    //velocity = Tests.CreatePathlineSpiral(99, 100, 2);
            //    velocity.ScaleToGrid(new Vec2(RedSea.Singleton.DomainScale));
            //}

            Console.WriteLine("Completed loading data.");

            CriticalPointSet2D[] cps = new CriticalPointSet2D[numTimeSlices];
            for (int time = 0; time < numTimeSlices; ++time)
            {
                //                cps[time] = FieldAnalysis.ComputeCriticalPointsRegularSubdivision2D(velocity.GetTimeSlice(time), 5, 0.3f);
                //                cps[time].SelectTypes(new CriticalPoint2D.TypeCP[] { CriticalPoint2D.TypeCP.ATTRACTING_FOCUS, CriticalPoint2D.TypeCP.REPELLING_FOCUS }).ToBasicSet();

                Console.WriteLine("Completed processing step " + time + '.');
            }

            redSea = new Plane(new Vector3(-10, -3, -5), Vector3.UnitX * 0.1f, Vector3.UnitY * 0.1f, -Vector3.UnitZ, 0.4f/*10f/size*/, 0.1f);
            //            mapperCP = new CriticalPointTracking(cps, velocity, redSea);
            //Console.WriteLine("Found CP.");
            //mapperPathCore = new PathlineCoreTracking(velocity, redSea);
            //Console.WriteLine("Found Pathline Cores.");
            mapperComparison = new MemberComparison(/*new LoaderNCF.SliceRange[] { sliceU, sliceV },*/ redSea);
            if (velocity != null)
            {
                mapperOW = new OkuboWeiss(velocity, redSea);
                Console.WriteLine("Computed Okubo-Weiss.");
            }

            Console.WriteLine("Computed all data necessary.");
        }
示例#22
0
 public Plane(Plane cpy, Vector3 offset)
 {
     Origin = cpy.Origin
         + offset.X * cpy.XAxis
         + offset.Y * cpy.YAxis
         + offset.Z * cpy.ZAxis;
     XAxis = cpy.XAxis;
     YAxis = cpy.YAxis;
     ZAxis = cpy.ZAxis;
     PointSize = cpy.PointSize;
 }
示例#23
0
 public ConcentricDifference(int everyNthField, Plane plane)
     : base(everyNthField, plane)
 {
     Mapping = Map;
 }
示例#24
0
 public PathlineCoreTracking(VectorFieldUnsteady velocity, /*VectorField fffPos, VectorField fffNeg,*/ Plane plane)
 {
     Velocity = new VectorField(velocity, FieldAnalysis.PathlineCore, 3);
     CP = new CriticalPointSet2D[velocity.Size.T];
     for (int slice = 0; slice < velocity.Size.T; ++slice)
     {
         CP[slice] = FieldAnalysis.ComputeCriticalPointsRegularSubdivision2D(Velocity.GetSlicePlanarVelocity(slice), 5, 0.3f);
     }
     // Render original field.
     SlicesToRender = new VectorField[velocity.Size.T];
     for (int slice = 0; slice < velocity.Size.T; ++slice)
     {
         SlicesToRender[slice] = Velocity.GetSlice(slice);
     }
     Mapping = TrackCP;
     Plane = plane;
 }
示例#25
0
 public ConcentricTubeMapper(int everyNthField, Plane plane)
     : base(everyNthField, plane)
 {
     Mapping = Map;
     Plane = new Plane(Plane, 12);
 }
示例#26
0
        // : base(plane, velocity.Size.ToInt2())
        public PathlineRadius(VectorFieldUnsteady velocity, Plane plane)
        {
            _velocity = velocity;
            Plane = plane;
            _intersectionPlane = new Plane(Plane, (velocity.TimeSlice ?? 0) * Plane.ZAxis);

            Mapping = AdvectLines;
        }
示例#27
0
        public MemberComparison(/*LoaderNCF.SliceRange[] ranges,*/ Plane plane)
        {
            //Debug.Assert(ranges.Length == 2);
            //_ranges = ranges;
            _fields = new FieldPlane[2];
            Plane = plane;
            Mapping = LoadMembers;

            //LoaderNCF ncFile = RedSea.Singleton.GetLoaderNCF(0);

            //int sizeVar = ncFile.GetNumVariables();
            //_variableRanges = new LoaderNCF.SliceRange[sizeVar];

            ////LoaderNCF.SliceRange ensembleU = new LoaderNCF.SliceRange(ncFile, RedSea.Variable.VELOCITY_X);
            ////ensembleU.SetMember(RedSea.Dimension.TIME, 0);
            ////LoaderNCF.SliceRange ensembleV = new LoaderNCF.SliceRange(ncFile, RedSea.Variable.VELOCITY_Y);
            ////ensembleV.SetMember(RedSea.Dimension.TIME, 0);
            ////LoaderNCF.SliceRange ensembleSal = new LoaderNCF.SliceRange(ncFile, RedSea.Variable.SALINITY);
            ////ensembleSal.SetMember(RedSea.Dimension.TIME, 0);
            ////LoaderNCF.SliceRange ensembleTemp = new LoaderNCF.SliceRange(ncFile, RedSea.Variable.TEMPERATURE);
            ////ensembleTemp.SetMember(RedSea.Dimension.TIME, 0);
            ////LoaderNCF.SliceRange ensembleHeight = new LoaderNCF.SliceRange(ncFile, RedSea.Variable.SURFACE_HEIGHT);
            ////ensembleHeight.SetMember(RedSea.Dimension.TIME, 0);

            ////_variableRanges[(int)RedSea.Variable.VELOCITY_X] = ensembleU;
            ////_variableRanges[(int)RedSea.Variable.VELOCITY_Y] = ensembleV;
            ////_variableRanges[(int)RedSea.Variable.SALINITY] = ensembleSal;
            ////_variableRanges[(int)RedSea.Variable.TEMPERATURE] = ensembleTemp;
            ////_variableRanges[(int)RedSea.Variable.SURFACE_HEIGHT] = ensembleHeight;
            //_variableRange = new LoaderRaw.SliceRangeRaw();
            //_variableRange.SetMember(RedSea.Dimension.TIME, 0);

            _loader = new LoaderRaw();
            _loader.Range.SetMember(RedSea.Dimension.SUBTIME, 0);

            //ncFile.Close();
        }
示例#28
0
 public Plane(Plane cpy, float zScale)
 {
     Origin = cpy.Origin;
     XAxis  = cpy.XAxis;
     YAxis  = cpy.YAxis;
     ZAxis  = cpy.ZAxis * zScale;
     PointSize = cpy.PointSize;
 }
示例#29
0
        /// <summary>
        /// Setting up the vertex buffer. Vertex size and number has to be known.
        /// </summary>
        /// <param name="origin"></param>
        /// <param name="xAxis"></param>
        /// <param name="yAxis"></param>
        /// <param name="scale"></param>
        protected void GenerateGeometry(Plane plane, PointSet<Point> points)
        {
            // Write poition and UV-map data.
            var stream = new DataStream(_numVertices * _vertexSizeBytes, true, true);
            Vector3 zAxis = plane.ZAxis;
            foreach(Point point in points.Points)
            {
                var test = new Vector4(plane.Origin + (plane.XAxis * point.Position[0] + plane.YAxis * point.Position[1] + zAxis * point.Position[2]), 1.0f);
                stream.Write(new Vector4(plane.Origin + (plane.XAxis * point.Position[0] + plane.YAxis * point.Position[1] + zAxis * point.Position[2]), 1.0f));
                stream.Write(point.Color);
                stream.Write(point.Radius * plane.PointSize);
            }
            stream.Position = 0;

            // Create and fill buffer.
            _vertices = new Buffer(Renderable._device, stream, new BufferDescription()
            {
                BindFlags = BindFlags.VertexBuffer,
                CpuAccessFlags = CpuAccessFlags.None,
                OptionFlags = ResourceOptionFlags.None,
                SizeInBytes = _numVertices * _vertexSizeBytes,
                Usage = ResourceUsage.Default
            });
            stream.Dispose();
        }
示例#30
0
        public OkuboWeiss(VectorFieldUnsteady velocity, Plane plane)
        {
            Debug.Assert(velocity.NumVectorDimensions == 2 + 1);
            _fieldOW = velocity;

            Plane = plane;
            Mapping = GetTimeSlice;
        }