Esempio n. 1
0
            private VtkToken GetVtkToken()
            {
                var tok = VtkToken.Invalid;

                VtkToken.TryParse(GetStringPart(), out tok);
                return(tok);
            }
Esempio n. 2
0
            protected void LoadPolydata(VtkPolyData polydata)
            {
                while (!EndOfFile)
                {
                    _curToken = GetVtkToken();
                    switch (_curToken)
                    {
                    case VtkToken.Points:
                        LoadPoints(polydata);
                        break;

                    case VtkToken.Vertices:
                    case VtkToken.Lines:
                    case VtkToken.Polygons:
                    case VtkToken.TriangleStrips:
                        LoadPolydataItems(polydata);
                        break;

                    case VtkToken.UnknowMetadata:
                        SkipMetadata();
                        break;

                    case VtkToken.None:
                        break;

                    default:
                        return;
                    }
                }
            }
Esempio n. 3
0
            protected void LoadUnstructuredGrid(VtkUnstructuredGrid dataset)
            {
                while (!EndOfFile)
                {
                    _curToken = GetVtkToken();
                    switch (_curToken)
                    {
                    case VtkToken.Points:
                        LoadPoints(dataset);
                        break;

                    case VtkToken.Cells:
                        LoadCells(dataset);
                        break;

                    case VtkToken.CellTypes:
                        LoadCellTypes(dataset);
                        break;

                    case VtkToken.UnknowMetadata:
                        SkipMetadata();
                        break;

                    case VtkToken.None:
                        break;

                    default:
                        return;
                    }
                }
            }
Esempio n. 4
0
            protected void LoadDataset(VtkModel model)
            {
                _curToken = GetVtkToken();
                switch (_curToken)
                {
                //                case VtkToken.StructuredPoint:break;
                //                case VtkToken.StructuredGrid:break;
                case VtkToken.UnstructuredGrid:
                    var usGrid = new VtkUnstructuredGrid();
                    LoadUnstructuredGrid(usGrid);
                    model.DataSet = usGrid;
                    break;

                case VtkToken.Polydata:
                    var polydata = new VtkPolyData();
                    LoadPolydata(polydata);
                    model.DataSet = polydata;
                    break;

                //                case VtkToken.RectilinearGrid:break;
                //                case VtkToken.Field:break;
                case VtkToken.UnknowMetadata:
                    SkipMetadata();
                    break;

                default:
                    throw new NotImplementedException(String.Format("unsupported vtk token: {0}.", _curToken));
                    break;
                }
            }
Esempio n. 5
0
            protected void LoadDataAttribs(Dictionary <string, VtkDataAttribute> attributes, int size)
            {
                while (!EndOfFile)
                {
                    _curToken = GetVtkToken();
                    switch (_curToken)
                    {
                    case VtkToken.Scalars:
                    case VtkToken.ColorScalars:
                        LoadScalars(attributes, size);
                        break;

                    case VtkToken.LookupTable:
                        LoadLookupTable(attributes, size);
                        break;

                    case VtkToken.Vectors:
                    case VtkToken.Normals:
                        LoadVectorsOrNormals(attributes, size);
                        break;

                    case VtkToken.Field:
                        LoadField(attributes, size);
                        break;

                    case VtkToken.UnknowMetadata:
                        SkipMetadata();
                        break;

                    case VtkToken.None:
                        break;

                    case VtkToken.TextureCoordinates:
                        LoadTextureCoordinates(attributes, size);
                        break;

                    case VtkToken.Tensors:
                        throw new NotImplementedException(String.Format("unsupported vtk token: {0}.", _curToken));
                        break;

                    default:
                        return;
                    }
                }
            }
Esempio n. 6
0
            protected void SkipMetadata()
            {
                _curPartIdx = _curLineParts.Length;//danger, used for skip this line
                while (!EndOfFile)
                {
                    _curToken = GetVtkToken();
                    switch (_curToken)
                    {
                    case VtkToken.UnknownInformation:
                    case VtkToken.UnknownName:
                    case VtkToken.UnknownData:
                        _curPartIdx = _curLineParts.Length;  //danger, used for skip this line
                        break;

                    default:
                        return;
                    }
                }
            }
Esempio n. 7
0
            public VtkModel Load()
            {
                var model = new VtkModel();

                if (!LoadHeader(model))
                {
                    return(null);
                }
                while (!EndOfFile)
                {
                    if (_curToken == VtkToken.None)
                    {
                        _curToken = GetVtkToken();
                    }
                    switch (_curToken)
                    {
                    case VtkToken.Dataset:
                        LoadDataset(model);
                        break;

                    case VtkToken.CellData:
                        LoadCellData(model);
                        break;

                    case VtkToken.PointData:
                        LoadPointData(model);
                        break;

                    case VtkToken.UnknowMetadata:
                        SkipMetadata();
                        break;

                    default:
                        throw new NotImplementedException(string.Format("unsupported vtk token:{0}.", _curToken));
                        break;
                    }
                }
                return(model);
            }
Esempio n. 8
0
            protected void LoadField(Dictionary <string, VtkDataAttribute> attributes, int size)
            {
                var fields = new FieldData();

                fields.Name             = GetStringPart();
                attributes[fields.Name] = fields;

                var numArrays = GetCount();

                Debug.WriteLine(string.Format("FIELD name: {0}, numArrays: {1}", fields.Name, numArrays));
                fields.Arrays = new Dictionary <string, FieldDataItem>(numArrays);

                int ac = 0;

                while (!EndOfFile && ac < numArrays)
                {
                    var name = GetStringPart();
                    if (string.IsNullOrEmpty(name))
                    {
                        continue;
                    }
                    var item = new FieldDataItem();
                    item.Name           = name;
                    item.ComponentCount = GetCount();
                    var numTuples = GetCount();
                    var dtType    = GetDataType();
                    Debug.WriteLine(string.Format("FieldData name: {0}, numComp: {1}, numTuple: {2}, dtType: {3}", item.Name, item.ComponentCount, numTuples, dtType));
                    item.Tuples = new List <float[]>(numTuples);
                    for (int j = 0; j < numTuples; j++)
                    {
                        var arr = new float[item.ComponentCount];
                        for (int k = 0; k < item.ComponentCount; k++)
                        {
                            arr[k] = GetDataAsFloat(dtType);
                        }
                        item.Tuples.Add(arr);
                    }
                    fields.Arrays.Add(item.Name, item);

                    //danger here
                    bool stop = false;
                    while (!stop)
                    {
                        switch ((char)Peek())
                        {
                        case '\0':
                        case '\r':
                        case '\n':
                            GetLine();
                            break;

                        default:
                            stop = true;
                            break;
                        }
                    }
                    if (Peek() == (int)'M')
                    {
                        _curToken = GetVtkToken();
                        Debug.Assert(_curToken == VtkToken.METADATA);
                        SkipMetadata();
                    }

                    ac++;
                }
            }