Пример #1
0
        private void  DisplayTrainingLibraryImagesBottomClass(Object sender, EventArgs e)
        {
            PicesClass bottomClass = GetSelectedBottomClass();

            if ((bottomClass == null) || (trainingModel == null))
            {
                return;
            }

            String dir = trainingModel.DirectoryPathForClass(bottomClass);

            if (String.IsNullOrEmpty(dir))
            {
                return;
            }

            DisplayPicesImages dpi = new DisplayPicesImages(dir);

            String[] svNames = trainingModel.SupportVectorNames(selectedTopClass, bottomClass);
            if (svNames != null)
            {
                dpi.SummportVectorNames(svNames);
            }

            dpi.ShowDialog();
            dpi.Dispose();
            dpi = null;
        } /* DisplayTrainingLibraryImagesBottomClass */
Пример #2
0
        } /* InitializeTrainAndPredLevelFields */

        private void  ValidateTrainingModel()
        {
            if (string.IsNullOrEmpty(TrainingModelSelected.Text))
            {
                return;
            }

            trainingModelName  = TrainingModelSelected.Text;
            curSelModel        = new PicesTrainingConfigManaged(trainingModelName, runLog);
            trainingModelValid = curSelModel.Valid();
            if (!trainingModelValid)
            {
                String alarmMsg = "Error Loading Configuration File";
                alarmMsg += "\n\n";
                alarmMsg += curSelModel.LoadLogStream();

                MessageBox.Show(this, alarmMsg, "Could not load Config file", MessageBoxButtons.OK);
            }
            else
            {
                otherClass = curSelModel.OtherClass();
                if (crossValidation)
                {
                    GroundTruth.Text = "F:\\Pices\\SavedImages\\Cruise-WB0812_Station-DWH";
                }
                //GroundTruth.Text = curSelModel.RootDir ();

                origClassifierClasses = curSelModel.ExtractClassList();
                InitializeTrainAndPredLevelFields();
            }
        } /* ValidateTrainingModel */
Пример #3
0
        public ConfusionMatrix(PicesTrainingConfigManaged _config,
                               PicesClassList _classifierClasses,            /**< List of classes in origianl Classifier before reduction due to training level. */
                               TrainingModel2 _trainingModel,
                               String _modelName,
                               String _groundTruthRootDir,
                               uint _trainLevel,
                               uint _predLevel
                               )
        {
            config             = _config;
            trainingModel      = _trainingModel;
            groundTruthRootDir = _groundTruthRootDir;
            trainLevel         = _trainLevel;
            predLevel          = _predLevel;
            classifierClasses  = _classifierClasses;

            if (config != null)
            {
                otherClass = config.OtherClass();
            }

            InitializeComponent();
            classes = new PicesClassList();
            classes.Clear();

            ModelName.Text   = _modelName;
            GroundTruth.Text = _groundTruthRootDir;
        }
Пример #4
0
        } /* UpdateProcessDelete */

        private void  UpdateProcessMerge(PicesDataBase updDbConn)
        {
            RunLogAddMsg("Merging Class [" + selectedClass.Name + "]  into [" + mergeClass.Name + "]" + "\n");
            // First:   Update the Images table.
            // Second:  Update Classes table.

            String sqlCmd = "Call MLClassMergeComprehensive (" + "\"" + selectedClass.Name + "\"" + ", " +
                            "\"" + mergeClass.Name + "\"" +
                            ")";

            updDbConn.QueryStatement(sqlCmd, null);

            PicesClassList.UpdateParent(mergeClass, selectedClass);

            if (mergeClass.Parent != null)
            {
                if (mergeClass.Parent.Children != null)
                {
                    mergeClass.Parent.Children.Remove(mergeClass);
                }
            }
            selectedClass.StoredOnDataBase = false;

            selectedClass = mergeClass;
        } /* UpdateProcessMerge */
Пример #5
0
        public ChartSizeDistribution(String _cruise,
                                     String _station,
                                     String _deployment,
                                     PicesClass _classToPlot,
                                     PicesClassList _classes,
                                     PicesClassList _activeClasses,
                                     String _rootDir
                                     )
        {
            cruise        = _cruise;
            station       = _station;
            deployment    = _deployment;
            classToPlot   = _classToPlot;
            classes       = _classes;
            activeClasses = _activeClasses;
            rootDir       = _rootDir;

            lastSaveDirectory = OSservices.AddSlash(PicesSipperVariables.PicesReportDir()) + "AbundanceReports";

            statusMsgs = new PicesMsgQueue("ChartSizeDistribution-StatusMsgs");
            msgQueue   = new PicesMsgQueue("ChartSizeDistribution-RunLog");
            runLog     = new PicesRunLog(msgQueue);

            mainWinConn = PicesDataBase.GetGlobalDatabaseManagerNewInstance(runLog);

            configFileName = OSservices.AddSlash(PicesSipperVariables.ConfigurationDirectory()) + "ChartSizeDistribution.cfg";

            InitializeComponent();
        }
Пример #6
0
        private float  FractionThatIsAMatch(PicesClass knownClass,
                                            PicesClass predClass
                                            )
        {
            String[] knownLevels = knownClass.NameUpper.Split('_');
            String[] predLevels  = predClass.NameUpper.Split('_');

            if (knownLevels.Length < 1)
            {
                return(0);
            }

            int zed = Math.Min(knownLevels.Length, predLevels.Length);
            int numMatchedLevels = 0;

            for (int x = 0; x < zed; ++x)
            {
                if (knownLevels[x] == predLevels[x])
                {
                    numMatchedLevels = x;
                }
                else
                {
                    break;
                }
            }
            return((float)numMatchedLevels / (float)knownLevels.Length);
        } /* FractionThatIsAMatch */
Пример #7
0
        PlanktonClassStatisticsLoader statsLoader = null; // To determine total number of images that will be saved.


        public SavePlanktonData(PicesDataBase _dbConn,
                                PicesDataBaseImageGroup _group,
                                String _cruise,
                                String _station,
                                String _deployment,
                                String _sipperFileName,
                                PicesClass _mlClass,
                                char _classKeyToUse,
                                float _probMin,
                                float _probMax,
                                int _sizeMin,
                                int _sizeMax,
                                float _depthMin,
                                float _depthMax
                                )
        {
            dbConn         = _dbConn;
            group          = _group;
            cruise         = (_cruise == null) ? "" : _cruise;
            station        = (_station == null) ? "" : _station;
            deployment     = (_deployment == null) ? "" : _deployment;
            sipperFileName = (_sipperFileName == null) ? "" : _sipperFileName;
            mlClass        = _mlClass;
            classKeyToUse  = _classKeyToUse;

            probMin  = _probMin;
            probMax  = _probMax;
            sizeMin  = _sizeMin;
            sizeMax  = _sizeMax;
            depthMin = _depthMin;
            depthMax = _depthMax;

            runLog = new PicesRunLog();
            InitializeComponent();
        }
Пример #8
0
        } /* ValidateParentName */

        private void  ValidateMergeWithAnotherClass()
        {
            if (MergeCheckBox.Checked)
            {
                MergeClass.Visible         = true;
                MergeClass.ReadOnly        = true;
                MergeSearchButton.Visible  = true;
                MergeSearchButton.Enabled  = true;
                MergeHelpTextLabel.Visible = true;
                MergeHelpTextLabel.Enabled = true;
                MergeLabel.Visible         = true;
                MergeLabel.Enabled         = true;
                ClassName.Text             = selectedClass.Name;
                Description.Text           = selectedClass.Description;
                ParentName.Text            = selectedClass.ParentName;
                MandatoryBox.Checked       = selectedClass.Mandatory;
                SummarizeBox.Checked       = selectedClass.Summarize;
            }
            else
            {
                MergeClass.Enabled         = false;
                MergeClass.Visible         = false;
                MergeClass.ReadOnly        = true;
                mergeClass                 = null;
                MergeSearchButton.Visible  = false;
                MergeSearchButton.Enabled  = false;
                MergeHelpTextLabel.Visible = false;
                MergeHelpTextLabel.Enabled = false;
                MergeLabel.Visible         = false;
                MergeLabel.Enabled         = false;
            }
        } /* ValidateMergeWithAnotherClass */
Пример #9
0
        private void SelectClassButtom_Click(object sender, EventArgs e)
        {
            String         rootDir       = "";
            PicesClassList activeClasses = null;

            if (ActiveTrainingLibraries.Model1() != null)
            {
                rootDir       = ActiveTrainingLibraries.Model1().RootDir;
                activeClasses = ActiveTrainingLibraries.Model1().MLClasses();
            }

            if (classes == null)
            {
                classes = dbConn.MLClassLoadList();
            }
            SelectAPicesClass sapc = new SelectAPicesClass(classes, rootDir, activeClasses);

            if (!String.IsNullOrEmpty(ValidatedClassName.Text))
            {
                sapc.SelectedClass = PicesClassList.GetUniqueClass(ValidatedClassName.Text, "");
            }

            sapc.ShowDialog(this);
            if (sapc.SelectionMade && (sapc.SelectedClass != null))
            {
                PicesClass validatdClass = sapc.SelectedClass;
                ValidatedClassName.Text = validatdClass.Name;
                image.ValidatedClass    = validatdClass;
                dbConn.ImagesUpdateValidatedClass(image.ImageFileName, validatdClass);
                classUserValidatesAs = validatdClass;
            }
        }
Пример #10
0
        } /* InitiateClass */

        public void   Increment(PicesClass mlClass,
                                float areaMM
                                )
        {
            if (mlClass == null)
            {
                mlClass = PicesClassList.GetUnKnownClassStatic();
            }

            ClassTotals2 classTotals = totals.LookUp(mlClass.Name);

            if (classTotals == null)
            {
                classTotals = new ClassTotals2(mlClass.Name,
                                               sizeInitial,
                                               sizeGrowthFactor,
                                               sizeEndRange,
                                               bucketCount,
                                               sizeBucketStart,
                                               sizeBucketEnd
                                               );
                totals.Add(classTotals);
            }

            classTotals.Increment(areaMM);
        } /* Increment */
Пример #11
0
        private List <String> ValidateFields()
        {
            List <String> errors = new List <string> ();

            weightByVolume    = WeightByVolume.Checked;
            includeSubClasses = IncludeSubClasses.Checked;

            depthIncrement = (int)DepthIncr.Value;
            if (depthIncrement < 1)
            {
                errors.Add("Depth Increment must be greater than zero.");
            }

            if (String.IsNullOrEmpty(ClassToPlot.Text))
            {
                errors.Add("You must specify class to plot.");
            }
            else
            {
                classToPlot = PicesClassList.GetUniqueClass(ClassToPlot.Text, "");
            }

            ValidateDepthAxisSettings(ref errors);

            if (errors.Count < 1)
            {
                return(null);
            }
            else
            {
                return(errors);
            }
        }
Пример #12
0
        } /* AddFamilyOfClassesToSizeClassTotals */

        /// <summary>
        /// Returns an instance of 'ClassTotals' that contains the ClassTotals that belong to the family of 'ancestor'.
        /// The newly instantiated instance will point to the same instances of 'ClassTotals'  that this instance points to.
        /// As a result you should only call this method after you are done accumulating data.
        /// </summary>
        /// <param name="ancestor"></param>
        /// <returns></returns>
        public SizeDistribution2  ExtractFamilyOfClasses(PicesClass ancestor)
        {
            SizeDistribution2 family = new SizeDistribution2(sizeInitial, sizeGrowthFactor, sizeEndRange);

            ExtractFamily(family, ancestor);
            return(family);
        } /* ExtractFamilyOfClasses */
Пример #13
0
        /// <summary>
        /// Returns an instance of 'ClassTotals' that contains a summary of the classes that are decedent of 'ancestor'.
        /// </summary>
        /// <param name="ancestor"></param>
        /// <returns></returns>
        public ClassTotals2  SummarizeFamilyOfClasses(PicesClass ancestor)
        {
            ClassTotals2 familySummary = new ClassTotals2(ancestor.Name, sizeInitial, sizeGrowthFactor, sizeEndRange, bucketCount, sizeBucketStart, sizeBucketEnd);

            AddFamilyOfClassesToSizeClassTotals(familySummary, ancestor);
            return(familySummary);
        } /* SummarizeFamilyOfClasses */
Пример #14
0
        /// <summary>
        ///
        /// </summary>
        /// <param name="classes"></param>
        /// <param name="_rootDir">Root directory of training library that contains examples for the classes.</param>
        /// <param name="_activeClasses">List of classes that current classifier supports;  these classes will be highlighted.</param>
        public SelectAPicesClass(PicesClassList classes,
                                 String _rootDir,
                                 PicesClassList _activeClasses
                                 )
        {
            activeClasses = _activeClasses;
            rootDir       = OSservices.AddSlash(_rootDir);
            InitializeComponent();

            activeClassFont = new Font(MLClassChoices.Font.FontFamily, MLClassChoices.Font.SizeInPoints + 1, FontStyle.Bold);

            selectedNode = null;

            PicesClass root        = classes.RootNode;
            bool       activeClass = false;

            AddSubTreeToClassChoser(root, MLClassChoices.Nodes, ref activeClass, 0);
            if (selectedNode != null)
            {
                MLClassChoices.SelectedNode = selectedNode;
            }

            MLClassChoices.ExpandAll();

            //foreach  (PicesClass pc in root.Children)
            //  AddSubTreeToClassChoser (pc, MLClassChoices.Nodes, ref activeClass);
        }
Пример #15
0
        } /* DetermineKnownIdxAndPredIdx */

        private void  ExploreMatrixCell(int mouseRow,
                                        int mouseCol
                                        )
        {
            int knownIDX     = 0;
            int predIDX      = 0;
            int matrixRowIdx = 0;

            if (matrixRowClassAssigned == null)
            {
                return;
            }

            DetermineKnownIdxAndPredIdx(mouseRow, mouseCol, ref matrixRowIdx, ref predIDX);
            if ((knownIDX < 0) || (matrixRowIdx >= matrixRowClassAssigned.Count) || (predIDX < 0) || (predIDX >= numPredClasses))
            {
                return;
            }

            PicesClass knownClass = matrixRowClassAssigned[matrixRowIdx];

            knownIDX = classesPredLevel.IndexOf(knownClass);
            if (knownIDX < 0)
            {
                return;
            }

            ImageListDisplay imagesDisplay = new ImageListDisplay(groundTruthRootDir,
                                                                  imagesByPred[knownIDX][predIDX],
                                                                  trainingModel
                                                                  );

            imagesDisplay.ShowDialog();
        } /* ExploreMatrixCell */
Пример #16
0
        } /* UpdateDetailProbabilityDisplay */

        private void  UpdateBinaryClassifierProbabilities(String className)
        {
            PicesClass leftClass = PicesClassList.GetUniqueClass(className, "");

            BinaryClassName.Text = "";

            BinaryProbabilities.Rows.Clear();

            Prediction pred = GetPrediction(curSelImageFileName);

            PicesPredictionList binaryPredictions = pred.trainModel.BinaryProbailitiesForClass(leftClass);

            if (binaryPredictions == null)
            {
                return;
            }

            BinaryClassName.Text = leftClass.Name;

            foreach (PicesPrediction p in binaryPredictions)
            {
                if (leftClass == p.MLClass)
                {
                    continue;
                }

                Object[] data = new Object[2];

                data[0] = p.ClassName;
                double probForRightSide = 1.0 - p.Probability;
                data[1] = probForRightSide;
                BinaryProbabilities.Rows.Add(data);
            }
        } /* UpdateBinaryClassifierProbabilities */
Пример #17
0
        } /* ExploreMatrixCell */

        public void  MakePrediction(PicesClass knownClass,
                                    PicesClass predictedClass,
                                    double predProb,
                                    PicesFeatureVector fv,
                                    TrainingModel2 trainModel
                                    )
        {
            bool partOfOriginalClassifier = ClassInClassifierClasses(knownClass);

            if (!partOfOriginalClassifier)
            {
                String notPartClassName = "(V)" + knownClass.Name;
                knownClass = PicesClassList.GetUniqueClass(notPartClassName, "");
            }

            int x = classes.LookUpIndex(knownClass);

            if (x < 0)
            {
                classes.Add(knownClass);
            }

            x = classes.LookUpIndex(predictedClass);
            if (x < 0)
            {
                classes.Add(predictedClass);
            }

            Prediction p = new Prediction(knownClass, predictedClass, predProb, fv, trainModel, partOfOriginalClassifier);

            predictions.Add(p);
        } /* featureVector */
Пример #18
0
        } /* ClassTree_AfterSelect */

        private void  StartUpdateProcedure()
        {
            if (!allowUpdates)
            {
                MessageBox.Show(this, "Updates are not allowed.", "Class Maintenance", MessageBoxButtons.OK);
                return;
            }

            if (addingNewClass)
            {
                newClassEntry = new PicesClass(ClassName.Text, ParentName.Text);
            }
            else
            {
                newClassEntry = selectedClass;
            }

            newClassEntry.Description = Description.Text;
            newClassEntry.Parent      = PicesClassList.GetUniqueClass(ParentName.Text, null);

            newClassEntry.Mandatory = MandatoryBox.Checked;
            newClassEntry.Summarize = SummarizeBox.Checked;

            DisableAllFields();
            updateThread = new Thread(new ThreadStart(UpdateProcess));
            updateThread.Start();
            Thread.Sleep(50);
            updateTimer.Enabled = true;

            UpdatingProgressBar.Value   = 0;
            UpdatingProgressBar.Visible = true;
        } /* PerformUpdate */
Пример #19
0
        } /* SumUpFamilyOfClassesForBucket */

        /// <summary>
        /// Returns an instance of 'ClassTotals' that contains a summary of the classes that are decedent of 'ancestor'.
        /// The newly instantiated instance will point to the same instances of 'ClassTotals'  that this instance points to.
        /// As a result you should only call this method after you are done accumulating data.
        /// </summary>
        /// <param name="ancestor"></param>
        /// <returns></returns>
        public ClassTotals  SumUpFamilyOfClasses(PicesClass ancestor)
        {
            ClassTotals familySummary = new ClassTotals(ancestor.Name, bucketCount, bucketSize);

            AddFamilyOfClassesToSizeClassTotals(familySummary, ancestor);
            return(familySummary);
        } /* ExtractFamilyOfClasses */
Пример #20
0
        public ChartAbundanceByDeployment(String _cruise,
                                          String _station,
                                          String _deployment,
                                          PicesClass _classToPlot,
                                          int _sizeMin,
                                          int _sizeMax,
                                          float _probMin,
                                          float _probMax,
                                          float _depthMin,
                                          float _depthMax,
                                          char _classKeyToUse,
                                          PicesClassList _classes,
                                          PicesClassList _activeClasses,
                                          String _rootDir
                                          )
        {
            cruise        = _cruise;
            station       = _station;
            deployment    = _deployment;
            classToPlot   = _classToPlot;
            sizeMin       = _sizeMin;
            sizeMax       = _sizeMax;
            probMin       = _probMin;
            probMax       = _probMax;
            depthMin      = _depthMin;
            depthMax      = _depthMax;
            classKeyToUse = _classKeyToUse;
            classes       = _classes;
            activeClasses = _activeClasses;
            rootDir       = _rootDir;

            if ((sizeMin > 0) && (sizeMax <= 0))
            {
                sizeMax = int.MaxValue;
            }
            if ((probMin >= 0.0f) && (probMax <= 0.0f))
            {
                probMax = 1.0f;
            }
            if ((depthMin > 0.0f) && (depthMax <= 0.0f))
            {
                depthMax = float.MaxValue;
            }

            filterSize  = (sizeMin > 0) || ((sizeMax > 0) && (sizeMax > sizeMin));
            filterProb  = ((probMin > 0.0f) || (probMax < 1.0f)) && (probMax > probMin);
            filterDepth = ((depthMax > 0) && (depthMax > depthMin));

            statusMsgs = new PicesMsgQueue("ChartAbundanceByDeployment-StatusMsgs");
            msgQueue   = new PicesMsgQueue("ChartAbundanceByDeployment-RunLog");
            runLog     = new PicesRunLog(msgQueue);

            mainWinConn = PicesDataBase.GetGlobalDatabaseManagerNewInstance(runLog);

            configFileName = OSservices.AddSlash(PicesSipperVariables.ConfigurationDirectory()) + "ChartAbundanceByDeployment.cfg";

            BuildCriteriaString();

            InitializeComponent();
        }
Пример #21
0
        private void  SizeDistributionForAClass(PicesClass c,
                                                bool includeChildren,
                                                ref PicesImageSizeDistribution downCastAcumulated,
                                                ref PicesImageSizeDistribution upCastAcumulated
                                                )
        {
            statusMsgs.AddMsg("Extracting for Class[" + c.Name + "]");
            sbyte ch = (sbyte)statistic;
            PicesImageSizeDistribution classDownCast = null;
            PicesImageSizeDistribution classUpCast   = null;

            threadConn.ImagesSizeDistributionByDepth(this.cruise, this.station, this.deployment, c.Name,
                                                     0.0f, // MaxDepth
                                                     5.0f,
                                                     ch,
                                                     initialSizeValue,
                                                     growthRate,
                                                     (float)MaxSizeField.Value,
                                                     ref classDownCast,
                                                     ref classUpCast
                                                     );

            if (classDownCast != null)
            {
                if (downCastAcumulated == null)
                {
                    downCastAcumulated = classDownCast;
                }
                else
                {
                    downCastAcumulated.AddIn(classDownCast, runLog);
                }
            }

            if (classUpCast != null)
            {
                if (upCastAcumulated == null)
                {
                    upCastAcumulated = classUpCast;
                }
                else
                {
                    upCastAcumulated.AddIn(classUpCast, runLog);
                }
            }

            if (includeChildren)
            {
                foreach (PicesClass pc in  c.Children)
                {
                    if (cancelRequested)
                    {
                        break;
                    }
                    SizeDistributionForAClass(pc, includeChildren, ref downCastAcumulated, ref upCastAcumulated);
                }
            }
        } /* SizeDistributionForAClass */
Пример #22
0
        public void  SetTrainingModel(TrainingModel2 _trainingModel)
        {
            trainingModel = _trainingModel;

            if (otherClass == null)
            {
                otherClass = PicesClassList.GetUniqueClass("Other", "");
            }
        }
Пример #23
0
 private void SelectClassButton_Click(object sender, EventArgs e)
 {
     if (MLClassChoices.SelectedNode != null)
     {
         selectionMade = true;
         selectedClass = PicesClassList.GetUniqueClass(MLClassChoices.SelectedNode.Text, "");
         Close();
         return;
     }
 }
Пример #24
0
        private void  InsertAClass(Object sender, EventArgs e)
        {
            addingNewClass        = true;
            MergeCheckBox.Checked = false;
            PicesClass newSelectedClass = new PicesClass("", selectedClass);

            selectedClass = newSelectedClass;
            EnableAllFields();
            PopulateClassMaintenancePanel(selectedClass);
            ClassName.Focus();
        } /* InsertAClass */
Пример #25
0
        } /* DisplayWorstTrainingImages */

        private void DisplayWorstTrainingImages2(Object sender, EventArgs e)
        {
            PicesClass bottomClass = GetSelectedBottomClass();

            if (bottomClass == null)
            {
                return;
            }

            DisplayWorstTrainingImages2(bottomClass);
        } /* DisplayWorstTrainingImages */
Пример #26
0
            } /* SetSelectTreeNode */

            private void  AddSubTreeToClassChoser(PicesClass pc,
                                                  TreeNodeCollection nodes,
                                                  ref bool activeClass
                                                  )
            {
                bool iAmActive = false;

                if (activeClasses != null)
                {
                    iAmActive = (activeClasses.LookUpIndex(pc) >= 0);
                }
                bool oneOfMyChildrenAreActive = false;

                TreeNode tn = new TreeNode(pc.Name);

                nodes.Add(tn);
                if (pc == selectedClass)
                {
                    selectedNode = tn;
                }

                if (pc.Children != null)
                {
                    foreach (PicesClass child  in  pc.Children)
                    {
                        bool childActive = false;
                        AddSubTreeToClassChoser(child, tn.Nodes, ref childActive);
                        if (childActive)
                        {
                            oneOfMyChildrenAreActive = true;
                        }
                    }
                }

                if (iAmActive || oneOfMyChildrenAreActive)
                {
                    activeClass = true;
                    if (iAmActive)
                    {
                        tn.ForeColor = Color.DarkGreen;
                        tn.NodeFont  = activeClassFont;
                    }
                    else if (oneOfMyChildrenAreActive)
                    {
                        tn.ForeColor = Color.Green;
                    }
                }
                else
                {
                    tn.ForeColor = Color.Gray;
                }
            }
Пример #27
0
        public void  AddOne(PicesClass pc)
        {
            int index = IndexOfKey(pc.Name);

            if (index >= 0)
            {
                this[pc.Name].count += 1;
            }
            else
            {
                Add(pc.Name, new ClassStat(pc, 1));
            }
        } /* AddOne */
Пример #28
0
        } /* ValidateMergeWithAnotherClass */

        private void  ValidateMergeClass()
        {
            if (MergeCheckBox.Checked)
            {
                errorProvider1.SetError(MergeClass, null);
                mergeClass = mainDbConn.MLClassLoad(MergeClass.Text);
                if (mergeClass == null)
                {
                    errorProvider1.SetError(MergeClass, "You must select a valid class to merge to.");
                    validationErrorsFound = true;
                }
            }
        } /* ValidateMergeClass */
Пример #29
0
        } /* ImportValidatedClassAssignments */

        private PicesClass  GetClassFromName(PicesDataBase threadConn,
                                             String _name
                                             )
        {
            PicesClass pc = threadConn.MLClassLoad(_name);

            if (pc == null)
            {
                pc = new PicesClass(_name, "");
                threadConn.MLClassInsert(pc);
            }
            return(pc);
        }
Пример #30
0
        } /* ValidClassNameFormat */

        private void  ValidateClassName()
        {
            errorProvider1.SetError(ClassName, null);

            if (String.IsNullOrEmpty(ClassName.Text))
            {
                errorProvider1.SetError(ClassName, "Can not leave the name blank.");
                validationErrorsFound = true;
                return;
            }

            if (addingNewClass)
            {
                String errMsg = ValidClassNameFormat(ClassName.Text);
                if (errMsg != null)
                {
                    errorProvider1.SetError(ClassName, errMsg);
                    validationErrorsFound = true;
                }
                else
                {
                    PicesClass existingClass = mainDbConn.MLClassLoad(ClassName.Text);
                    if (existingClass != null)
                    {
                        errorProvider1.SetError(ClassName, "This name is already in use.");
                        validationErrorsFound = true;
                    }
                }
            }

            else if (ClassName.Text.ToUpper() != selectedClass.Name.ToUpper())
            {
                // Looks like user has changed the class name;  make sure it is not already in use."
                PicesClass existingClass = mainDbConn.MLClassLoad(ClassName.Text);
                if (existingClass != null)
                {
                    errorProvider1.SetError(ClassName, "This name is already in use.");
                    validationErrorsFound = true;
                }
                else
                {
                    String errMsg = ValidClassNameFormat(ClassName.Text);
                    if (errMsg != null)
                    {
                        errorProvider1.SetError(ClassName, errMsg);
                        validationErrorsFound = true;
                    }
                }
            }
            return;
        } /* ValidateClassName */