Assert() публичный статический Метод

public static Assert ( bool condition ) : void
condition bool
Результат void
        private static void LoadOpticalFlowBackwardFiles <TEmguImageStructure, TSize>(SegmenterImageStackLoadDescription segmenterImageStackLoadDescription, string opticalFlowVolumeName, string sourceVolumeName, ref Dictionary <VolumeDescription> volumeDescriptions)
            where TEmguImageStructure : struct, IColor
            where TSize : new()
        {
            //
            // load in each source image (using SlimDX just because this is the easiest way to access the raw bytes) and copy to client buffer
            //
            var sourceImageDirectory = segmenterImageStackLoadDescription.Directories.Get(sourceVolumeName);
            var sourceImageFileNames = from fileInfo in new DirectoryInfo(sourceImageDirectory).GetFiles("*.*") where !fileInfo.Name.Equals("Thumbs.db") select fileInfo.Name;
            var sourceImageFilePaths = from sourceImageFileName in sourceImageFileNames select Path.Combine(sourceImageDirectory, sourceImageFileName);

            if (sourceImageFilePaths.Count() > 1)
            {
                int width, height, depth;

                using (var image = new Image <TEmguImageStructure, TSize>(sourceImageFilePaths.First()))
                {
                    width  = image.Width;
                    height = image.Height;
                    depth  = sourceImageFilePaths.Count() - 1;
                }

                var volumeDataStream = new DataStream(width * height * depth * NUM_BYTES_PER_OPTICAL_FLOW_VOXEL, true, true);

                var fromFileStems = from sourceImageFileName in sourceImageFileNames.Skip(1)
                                    select new string( sourceImageFileName.Remove(sourceImageFileName.LastIndexOf(".")).ToCharArray());

                var toFileStems = from sourceImageFileName in sourceImageFileNames.Take(sourceImageFileNames.Count() - 1)
                                  select new string( sourceImageFileName.Remove(sourceImageFileName.LastIndexOf(".")).ToCharArray());

                var opticalFlowFileNames = fromFileStems.Select((fromFileStem, i) => fromFileStem + "-to-" + toFileStems.ElementAt(i) + ".raw");
                var opticalFlowFilePaths = from opticalFlowFileName in opticalFlowFileNames
                                           select
                                           Path.Combine(segmenterImageStackLoadDescription.Directories.Get(opticalFlowVolumeName),
                                                        opticalFlowFileName);

                foreach (var opticalFlowFilePath in opticalFlowFilePaths)
                {
                    Release.Assert(File.Exists(opticalFlowFilePath));

                    using (var opticalFlowFileStream = new FileStream(opticalFlowFilePath, FileMode.Open))
                    {
                        opticalFlowFileStream.CopyTo(volumeDataStream);
                    }
                }

                volumeDescriptions.Set(opticalFlowVolumeName,
                                       new VolumeDescription
                {
                    DxgiFormat       = Format.R32G32_Float,
                    DataStream       = volumeDataStream,
                    Data             = volumeDataStream.DataPointer,
                    NumBytesPerVoxel = NUM_BYTES_PER_OPTICAL_FLOW_VOXEL,
                    NumVoxelsX       = width,
                    NumVoxelsY       = height,
                    NumVoxelsZ       = depth,
                    IsSigned         = true
                });
            }
        }
Пример #2
0
        public void Scribble(int x, int y, ConstraintType constraintType, int brushWidth)
        {
            if (CurrentNeuralProcess != null)
            {
                Interop.ConvergenceGap      = Constants.Parameters.GetFloat("MAX_CONVERGENCE_GAP");
                Interop.ConvergenceGapDelta = Constants.Parameters.GetFloat("MAX_CONVERGENCE_GAP_DELTA");

                switch (constraintType)
                {
                case ConstraintType.Foreground:
                    Interop.AddForegroundHardConstraint(
                        new Vector3(x, y, CurrentSlice),
                        new Vector3(mMousePreviousX, mMousePreviousY, CurrentSlice),
                        brushWidth,
                        HardConstraintMode.Scribble);
                    break;

                case ConstraintType.Background:
                    Interop.AddBackgroundHardConstraint(
                        new Vector3(x, y, CurrentSlice),
                        new Vector3(mMousePreviousX, mMousePreviousY, CurrentSlice),
                        brushWidth,
                        HardConstraintMode.Scribble);
                    break;

                default:
                    Release.Assert(false);
                    break;
                }

                mMousePreviousX = x;
                mMousePreviousY = y;
            }
        }
        public static Effect CompileEffect(Device device, string effectFile)
        {
            Effect effect = null;

            var compilationSucceeded = false;

            while (!compilationSucceeded)
            {
                try
                {
                    Release.Assert(File.Exists(effectFile));

                    using (var shaderBytecode = ShaderBytecode.CompileFromFile(effectFile,
                                                                               "fx_5_0",
                                                                               ShaderFlags.None,
                                                                               EffectFlags.None))
                    {
                        effect = new Effect(device, shaderBytecode);
                        compilationSucceeded = true;
                    }
                }
                catch (Exception e)
                {
                    compilationSucceeded = false;
                    Release.Assert(false, e.Message);
                }
            }

            return(effect);
        }
        private static void LoadImages <TEmguImageStructure, TSize>(SegmenterImageStackLoadDescription segmenterImageStackLoadDescription, string volumeName, ref Dictionary <VolumeDescription> volumeDescriptions)
            where TEmguImageStructure : struct, IColor
            where TSize : new()
        {
            //
            // load in each source image and copy to client buffer
            //
            var imageDirectory = segmenterImageStackLoadDescription.Directories.Get(volumeName);
            var imageFileNames = from fileInfo in new DirectoryInfo(imageDirectory).GetFiles("*.*") where !fileInfo.Name.Equals("Thumbs.db") select fileInfo.Name;
            var imageFilePaths = from imageFileName in imageFileNames select Path.Combine(imageDirectory, imageFileName);

            Release.Assert(imageFilePaths.Count() > 0);

            int width, height, depth;

            using (var image = new Image <TEmguImageStructure, TSize>(imageFilePaths.First()))
            {
                width  = image.Width;
                height = image.Height;
                depth  = imageFilePaths.Count();
            }

            var volumeDataStream = new DataStream(width * height * depth * segmenterImageStackLoadDescription.NumBytesPerVoxel, true, true);

            foreach (var imageFilePath in imageFilePaths)
            {
                using (var image = new Image <TEmguImageStructure, TSize>(imageFilePath))
                {
                    volumeDataStream.Write(image.Bytes, 0, image.Bytes.Length);

                    Release.Assert(width == image.Width);
                    Release.Assert(height == image.Height);
                }
            }

            volumeDescriptions.Set(volumeName,
                                   new VolumeDescription
            {
                DxgiFormat       = segmenterImageStackLoadDescription.DxgiFormat,
                DataStream       = volumeDataStream,
                Data             = volumeDataStream.DataPointer,
                NumBytesPerVoxel = segmenterImageStackLoadDescription.NumBytesPerVoxel,
                NumVoxelsX       = width,
                NumVoxelsY       = height,
                NumVoxelsZ       = depth,
                IsSigned         = segmenterImageStackLoadDescription.IsSigned
            });
        }
Пример #5
0
        public static TXml ReadFromFile <TXml, TXmlSerializer>(string fileName) where TXmlSerializer : XmlSerializer, new()
        {
            try
            {
                var xmlSerializer = new TXmlSerializer();

                // A FileStream is needed to read the XML document.
                using (var fileStream = new FileStream(fileName, FileMode.Open))
                {
                    System.Xml.XmlReader xmlTextReader = new XmlTextReader(fileStream);

                    // Declare an object variable of the type to be deserialized.
                    return((TXml)xmlSerializer.Deserialize(xmlTextReader));
                }
            }
            catch (Exception)
            {
                Release.Assert(false);
            }

            return(default(TXml));
        }
Пример #6
0
        public void InitializeConstraintMapAndSegmentationFromBreadcrumbs()
        {
            if (DatasetDescription.NeuralProcessDescriptions.Count > 0)
            {
                Release.Assert(CurrentNeuralProcess != null);

                var backgroundBreadcrumbs = from neuralProcessDescription in DatasetDescription.NeuralProcessDescriptions.Values
                                            from breadcrumb in neuralProcessDescription.BreadcrumbDescriptions
                                            where !neuralProcessDescription.Color.Equals(CurrentNeuralProcess.Color)
                                            select breadcrumb;


                backgroundBreadcrumbs.ToList().ForEach(
                    breadcrumb => Interop.AddBackgroundHardConstraint(breadcrumb.Position,
                                                                      Constants.MIN_BRUSH_WIDTH,
                                                                      HardConstraintMode.Breadcrumb));

                CurrentNeuralProcess.BreadcrumbDescriptions.ToList().ForEach(
                    breadcrumb => Interop.AddForegroundHardConstraint(breadcrumb.Position,
                                                                      Constants.MIN_BRUSH_WIDTH,
                                                                      HardConstraintMode.Breadcrumb));
            }
        }
Пример #7
0
        public void SelectNeuralProcess(int id)
        {
            switch (CurrentSegmenterToolMode)
            {
            case SegmenterToolMode.Adjust:

                SaveOldNeuralProcess();
                CurrentNeuralProcess = DatasetDescription.NeuralProcessDescriptions[id];
                InitializeNewNeuralProcess();
                break;

            case SegmenterToolMode.Merge:
                Release.Assert(false);
                break;

            case SegmenterToolMode.Split:
                CurrentNeuralProcess = DatasetDescription.NeuralProcessDescriptions[id];
                break;

            default:
                Release.Assert(false);
                break;
            }
        }
        private static void LoadIdMapImages(SegmenterImageStackLoadDescription segmenterImageStackLoadDescription, string volumeName, ref Dictionary <VolumeDescription> volumeDescriptions)
        {
            //
            // load in each source image and copy to client buffer
            //
            var imageDirectory = segmenterImageStackLoadDescription.Directories.Get(volumeName);

            var imageFileNames = from fileInfo in new DirectoryInfo(imageDirectory).GetFiles("*.*") where !fileInfo.Name.Equals("Thumbs.db") select fileInfo.Name;
            var imageFilePaths = from imageFileName in imageFileNames select Path.Combine(imageDirectory, imageFileName);

            Release.Assert(imageFilePaths.Count() > 0);

            int width, height, depth;

            using (var image = new Image <Gray, UInt16>(imageFilePaths.First()))
            {
                width  = image.Width;
                height = image.Height;
                depth  = imageFilePaths.Count();
            }

            var volumeDataStream = new DataStream(width * height * depth * segmenterImageStackLoadDescription.NumBytesPerVoxel, true, true);

            foreach (var imageFilePath in imageFilePaths)
            {
                var tmpImagePointer = CvInvoke.cvLoadImage(imageFilePath, LOAD_IMAGE_TYPE.CV_LOAD_IMAGE_UNCHANGED);
                using (var tmpImage = new Image <Gray, UInt16>(width, height))
                {
                    Release.Assert(width == tmpImage.Width);
                    Release.Assert(height == tmpImage.Height);

                    CvInvoke.cvCopy(tmpImagePointer, tmpImage, IntPtr.Zero);

                    for (var y = 0; y < height; y++)
                    {
                        for (var x = 0; x < width; x++)
                        {
                            var idMapValue = tmpImage[y, x];

                            volumeDataStream.Write((int)idMapValue.Intensity);
                        }
                    }
                }

                CvInvoke.cvReleaseImage(ref tmpImagePointer);
            }



            volumeDescriptions.Set(volumeName,
                                   new VolumeDescription
            {
                DxgiFormat       = segmenterImageStackLoadDescription.DxgiFormat,
                DataStream       = volumeDataStream,
                Data             = volumeDataStream.DataPointer,
                NumBytesPerVoxel = segmenterImageStackLoadDescription.NumBytesPerVoxel,
                NumVoxelsX       = width,
                NumVoxelsY       = height,
                NumVoxelsZ       = depth,
                IsSigned         = segmenterImageStackLoadDescription.IsSigned
            });
        }
// ReSharper restore InconsistentNaming

        public void LoadDataset(DatasetDescription datasetDescription)
        {
            Release.Assert(false);

            //datasetDescription.NeuralProcessDescriptions.Get( "Trail 1" ).BreadcrumbDescriptions.Add(
            //    datasetDescription.NeuralProcessDescriptions.Get( "Trail 2" ).BreadcrumbDescriptions.First() );

            //datasetDescription.NeuralProcessDescriptions.Get( "Trail 1" ).BreadcrumbDescriptions.Add(
            //    datasetDescription.NeuralProcessDescriptions.Get( "Trail 3" ).BreadcrumbDescriptions.First() );

            //datasetDescription.NeuralProcessDescriptions.Get( "Trail 1" ).BreadcrumbDescriptions.Add(
            //    datasetDescription.NeuralProcessDescriptions.Get( "Trail 4" ).BreadcrumbDescriptions.First() );

            //datasetDescription.NeuralProcessDescriptions.Get( "Trail 1" ).BreadcrumbDescriptions.Add(
            //    datasetDescription.NeuralProcessDescriptions.Get( "Trail 5" ).BreadcrumbDescriptions.First() );

            //datasetDescription.NeuralProcessDescriptions.Get( "Trail 1" ).BreadcrumbDescriptions.Add(
            //    datasetDescription.NeuralProcessDescriptions.Get( "Trail 6" ).BreadcrumbDescriptions.First() );

            //datasetDescription.NeuralProcessDescriptions.Get( "Trail 1" ).BreadcrumbDescriptions.Add(
            //    datasetDescription.NeuralProcessDescriptions.Get( "Trail 7" ).BreadcrumbDescriptions.First() );

            //datasetDescription.NeuralProcessDescriptions.Get( "Trail 1" ).Branches =
            //    new List<Edge>
            //            {
            //                new Edge
            //                     {
            //                         P1 = datasetDescription.NeuralProcessDescriptions.Get( "Trail 2" ).BreadcrumbDescriptions.First().Position,
            //                         P2 = datasetDescription.NeuralProcessDescriptions.Get( "Trail 3" ).BreadcrumbDescriptions.First().Position
            //                     },
            //                new Edge
            //                     {
            //                         P1 = datasetDescription.NeuralProcessDescriptions.Get( "Trail 4" ).BreadcrumbDescriptions.First().Position,
            //                         P2 = datasetDescription.NeuralProcessDescriptions.Get( "Trail 5" ).BreadcrumbDescriptions.First().Position
            //                     },
            //                new Edge
            //                     {
            //                         P1 = datasetDescription.NeuralProcessDescriptions.Get( "Trail 6" ).BreadcrumbDescriptions.First().Position,
            //                         P2 = datasetDescription.NeuralProcessDescriptions.Get( "Trail 7" ).BreadcrumbDescriptions.First().Position
            //                     }
            //            };

            //datasetDescription.NeuralProcessDescriptions.Internal =
            //    new ObservableDictionary< string, NeuralProcessDescription >(
            //        ( from neuralProcessDescription in
            //              datasetDescription.NeuralProcessDescriptions.Internal
            //          where neuralProcessDescription.Key == "Trail 1"
            //          select neuralProcessDescription ).ToDictionary( b => b.Key,
            //                                                          b => b.Value ) );



            //Interop.LoadDataset( datasetDescription );

            //VolumeDescription = datasetDescription.VolumeDescriptions.Get( "SourceMap" );

            //var textureDesc3D = new Texture3DDescription
            //                    {
            //                        Width = VolumeDescription.NumVoxelsX,
            //                        Height = VolumeDescription.NumVoxelsY,
            //                        Depth = VolumeDescription.NumVoxelsZ,
            //                        MipLevels = 1,
            //                        Usage = ResourceUsage.Default,
            //                        BindFlags = BindFlags.ShaderResource,
            //                        Format = VolumeDescription.DxgiFormat
            //                    };

            //var shaderResourceViewDesc = new ShaderResourceViewDescription
            //                             {
            //                                 Format = VolumeDescription.DxgiFormat,
            //                                 Dimension = ShaderResourceViewDimension.Texture3D,
            //                                 MipLevels = -1
            //                             };

            //mSourceTexture = new Texture3D( mD3D11Device, textureDesc3D );

            //VolumeDescription.DataStream.Seek( 0, SeekOrigin.Begin );

            //mD3D11DeviceContext.UpdateSubresource(
            //    new DataBox(
            //        VolumeDescription.NumVoxelsX *
            //        VolumeDescription.NumBytesPerVoxel,
            //        VolumeDescription.NumVoxelsY *
            //        VolumeDescription.NumVoxelsX *
            //        VolumeDescription.NumBytesPerVoxel,
            //        VolumeDescription.DataStream ),
            //    mSourceTexture,
            //    0 );

            //SourceTexture = new ShaderResourceView( mD3D11Device, mSourceTexture, shaderResourceViewDesc );

            //AnisotropyFactor = 10f;

            //NormalizedVolumeExtent =
            //    new Vector3( 1f,
            //                 (float)VolumeDescription.NumVoxelsY / VolumeDescription.NumVoxelsX,
            //                 ( VolumeDescription.NumVoxelsZ * AnisotropyFactor ) / VolumeDescription.NumVoxelsX );

            //VolumeIndexToNormalizedVolumeCoordinates =
            //    Matrix.Scaling( NormalizedVolumeExtent.X / VolumeDescription.NumVoxelsX,
            //                    NormalizedVolumeExtent.Y / VolumeDescription.NumVoxelsY,
            //                    NormalizedVolumeExtent.Z / VolumeDescription.NumVoxelsZ );

            //NormalizedVolumeCoordinatesToWorldCoordinates =
            //    Matrix.Reflection( new Plane( Vector3.Zero, Vector3.UnitY ) ) *
            //    Matrix.Translation( 0f, NormalizedVolumeExtent.Y, 0f );

            //NormalizedVolumeCoordinatesToTextureCoordinates =
            //    Matrix.Scaling( 1f / NormalizedVolumeExtent.X,
            //                    1f / NormalizedVolumeExtent.Y,
            //                    1f / NormalizedVolumeExtent.Z );

            //Camera = new Camera( NormalizedVolumeExtent * 4f,
            //                     NormalizedVolumeExtent / 2f,
            //                     new Vector3( 0f, 1f, 0f ),
            //                     Matrix.PerspectiveFovLH( (float)Math.PI / 4, 1f, 0.1f, 100f ) );

            //NeuralProcessDescriptions = datasetDescription.NeuralProcessDescriptions;

            //AugmentedDelaunyEdges = AugmentDelaunyEdges( datasetDescription.NeuralProcessDescriptions, Interop.DelaunyEdges, VolumeIndexToNormalizedVolumeCoordinates );
            //ShortestPathDescriptions = ComputeShortestPaths( datasetDescription.NeuralProcessDescriptions, AugmentedDelaunyEdges, VolumeIndexToNormalizedVolumeCoordinates );
        }
        public ObservableDictionary <int, NeuralProcessDescription> LoadDataset(BreadcrumbXmlLoadDescription breadcrumbXmlLoadDescription)
        {
            var breadcrumbTrailCollectionDirectory = breadcrumbXmlLoadDescription.BreadcrumbTrailCollectionDirectory;

            var breadcrumbCollections = from fileInfo in new DirectoryInfo(breadcrumbTrailCollectionDirectory).GetFiles("*.*")
                                        select new
            {
                SectionId            = int.Parse(fileInfo.Name.Trim(TRIM_CHARS)),
                BreadcrumbCollection =
                    XmlReader.ReadFromFile <contours, contoursSerializer>(
                        Path.Combine(breadcrumbTrailCollectionDirectory, fileInfo.Name))
            };

            Release.Assert(breadcrumbCollections.Count() > 0);
            Release.Assert(breadcrumbCollections.All(breadcrumbCollection => breadcrumbCollection.BreadcrumbCollection.contour.All(breadcrumb => [email protected]("PointContour"))));

            var distinctNeuralProcessNames = (from breadcrumbCollection in breadcrumbCollections
                                              from breadcrumb in breadcrumbCollection.BreadcrumbCollection.contour
                                              select breadcrumb.name).Distinct();

            var distinctNeuralProcessIds = Enumerable.Range(1, distinctNeuralProcessNames.Count() + 1);
            var distinctNeuralProcesses  = distinctNeuralProcessIds.Zip(distinctNeuralProcessNames, (id, name) => new { Id = id, Name = name });

            var tmpBreadcrumbDescriptions = from breadcrumbCollection in breadcrumbCollections
                                            from breadcrumb in breadcrumbCollection.BreadcrumbCollection.contour
                                            select new
            {
                Name  = breadcrumb.name,
                Color = new Vector3(
                    int.Parse(breadcrumb.color.Substring(1, 2), NumberStyles.HexNumber),
                    int.Parse(breadcrumb.color.Substring(3, 2), NumberStyles.HexNumber),
                    int.Parse(breadcrumb.color.Substring(5, 2), NumberStyles.HexNumber)),
                BreadcrumbDescription = new BreadcrumbDescription
                {
                    Position = new Vector3(
                        breadcrumb.value.point.x - breadcrumbXmlLoadDescription.BreadcrumbTrailCoordinateOffset.X,
                        breadcrumb.value.point.y - breadcrumbXmlLoadDescription.BreadcrumbTrailCoordinateOffset.Y,
                        breadcrumbCollection.SectionId - breadcrumbXmlLoadDescription.BreadcrumbTrailCoordinateOffset.Z)
                }
            };

            var neuralProcesssToRemove    = Constants.REMOVE_BAD_PROCESSES ? Constants.BadProcesses : new List <string>();
            var neuralProcessDescriptions = new ObservableDictionary <int, NeuralProcessDescription>(
                (from distinctNeuralProcess in distinctNeuralProcesses
                 join breadcrumbDescription in tmpBreadcrumbDescriptions
                 on distinctNeuralProcess.Name equals breadcrumbDescription.Name
                 into breadcrumbDescriptionsWithTheSameName
                 where !neuralProcesssToRemove.Contains(distinctNeuralProcess.Name)
                 select new NeuralProcessDescription(distinctNeuralProcess.Id)
            {
                Name = distinctNeuralProcess.Name,
                Color = breadcrumbDescriptionsWithTheSameName.First().Color,
                BreadcrumbDescriptions =
                    (from breadcrumbDescription in breadcrumbDescriptionsWithTheSameName
                     select breadcrumbDescription.BreadcrumbDescription).ToList()
            }).ToDictionary(
                    neuralProcessDescription => neuralProcessDescription.Id,
                    neuralProcessDescription => neuralProcessDescription));

            return(neuralProcessDescriptions);
        }