Пример #1
0
        TryCalculateMotifs
        (
            IGraph graph,
            Motifs motifsToCalculate,
            Int32 dMinimum,
            Int32 dMaximum,
            Int32 nMinimum,
            Int32 nMaximum,
            BackgroundWorker backgroundWorker,
            out ICollection <Motif> motifs
        )
        {
            Debug.Assert(graph != null);

            List <Motif> oMotifs = new List <Motif>();

            motifs = oMotifs;

            if ((motifsToCalculate & Motifs.Fan) != 0)
            {
                ICollection <Motif> oFanMotifs;

                if (!TryCalculateFanMotifs(graph, backgroundWorker,
                                           out oFanMotifs))
                {
                    return(false);
                }

                oMotifs.AddRange(oFanMotifs);
            }

            if ((motifsToCalculate & Motifs.DConnector) != 0)
            {
                ICollection <Motif> oDConnectorMotifs;

                if (!TryCalculateDConnectorMotifs(graph, dMinimum, dMaximum, backgroundWorker,
                                                  out oDConnectorMotifs))
                {
                    return(false);
                }

                oMotifs.AddRange(oDConnectorMotifs);
            }

            if ((motifsToCalculate & Motifs.Clique) != 0)
            {
                ICollection <Motif> oCliqueMotifs;

                if (!TryCalculateCliqueMotifs(graph, nMinimum, nMaximum, backgroundWorker,
                                              oMotifs, out oCliqueMotifs))
                {
                    return(false);
                }

                oMotifs.AddRange(oCliqueMotifs);
            }

            return(true);
        }
Пример #2
0
        // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
        static void addImage(Motifs motif, string path)
        {
            var imageFullPath = Path.Combine(AppDomain.CurrentDomain.BaseDirectory, path);
            var image         = new BitmapImage(new Uri(imageFullPath));

            RenderOptions.SetBitmapScalingMode(image, BitmapScalingMode.NearestNeighbor);
            DicoTuiles.Add(motif, image);
        }
Пример #3
0
        DoDataExchange
        (
            Boolean bFromControls
        )
        {
            if (bFromControls)
            {
                Motifs eMotifsToCalculate = Motifs.None;

                if (chkFan.Checked)
                {
                    eMotifsToCalculate |= Motifs.Fan;
                }

                if (chkDConnector.Checked)
                {
                    eMotifsToCalculate |= Motifs.DConnector;

                    Int32 iDConnectorMinimumAnchorVertices,
                          iDConnectorMaximumAnchorVertices;

                    if (
                        !ValidateNumericUpDown(nudDConnectorMinimumAnchorVertices,
                                               "the minimum number of anchor vertices",
                                               out iDConnectorMinimumAnchorVertices)
                        ||
                        !ValidateNumericUpDown(nudDConnectorMaximumAnchorVertices,
                                               "the maximum number of anchor vertices",
                                               out iDConnectorMaximumAnchorVertices)
                        )
                    {
                        return(false);
                    }
                    else
                    {
                        // Don't require the minimum and maximum to be in the
                        // typical order.

                        m_oMotifUserSettings.DConnectorMinimumAnchorVertices =
                            Math.Min(iDConnectorMinimumAnchorVertices,
                                     iDConnectorMaximumAnchorVertices);

                        m_oMotifUserSettings.DConnectorMaximumAnchorVertices =
                            Math.Max(iDConnectorMinimumAnchorVertices,
                                     iDConnectorMaximumAnchorVertices);
                    }
                }

                if (chkClique.Checked)
                {
                    eMotifsToCalculate |= Motifs.Clique;

                    Int32 iCliqueMinimumMemberVertices,
                          iCliqueMaximumMemberVertices;

                    if (
                        !ValidateNumericUpDown(nudCliqueMinimumMemberVertices,
                                               "the minimum number of member vertices",
                                               out iCliqueMinimumMemberVertices)
                        ||
                        !ValidateNumericUpDown(nudCliqueMaximumMemberVertices,
                                               "the maximum number of member vertices",
                                               out iCliqueMaximumMemberVertices)
                        )
                    {
                        return(false);
                    }
                    else
                    {
                        // Don't require the minimum and maximum to be in the
                        // typical order.

                        m_oMotifUserSettings.CliqueMinimumMemberVertices =
                            Math.Min(iCliqueMinimumMemberVertices,
                                     iCliqueMaximumMemberVertices);

                        m_oMotifUserSettings.CliqueMaximumMemberVertices =
                            Math.Max(iCliqueMinimumMemberVertices,
                                     iCliqueMaximumMemberVertices);
                    }
                }

                m_oMotifUserSettings.MotifsToCalculate = eMotifsToCalculate;
            }
            else
            {
                chkFan.Checked        = ShouldGroupByMotif(Motifs.Fan);
                chkDConnector.Checked = ShouldGroupByMotif(Motifs.DConnector);
                chkClique.Checked     = ShouldGroupByMotif(Motifs.Clique);

                nudDConnectorMinimumAnchorVertices.Value =
                    m_oMotifUserSettings.DConnectorMinimumAnchorVertices;

                nudDConnectorMaximumAnchorVertices.Value =
                    m_oMotifUserSettings.DConnectorMaximumAnchorVertices;

                nudCliqueMinimumMemberVertices.Value =
                    m_oMotifUserSettings.CliqueMinimumMemberVertices;

                nudCliqueMaximumMemberVertices.Value =
                    m_oMotifUserSettings.CliqueMaximumMemberVertices;

                EnableControls();
            }

            return(true);
        }
    TryCalculateMotifs
    (
        IGraph graph,
        Motifs motifsToCalculate,
        Int32 dMinimum,
        Int32 dMaximum,
        Int32 nMinimum,
        Int32 nMaximum,
        BackgroundWorker backgroundWorker,
        out ICollection<Motif> motifs
    )
    {
        Debug.Assert(graph != null);

        List<Motif> oMotifs = new List<Motif>();
        motifs = oMotifs;

        if ((motifsToCalculate & Motifs.Fan) != 0)
        {
            ICollection<Motif> oFanMotifs;

            if (!TryCalculateFanMotifs(graph, backgroundWorker,
                out oFanMotifs))
            {
                return (false);
            }

            oMotifs.AddRange(oFanMotifs);
        }

        if ((motifsToCalculate & Motifs.DConnector) != 0)
        {
            ICollection<Motif> oDConnectorMotifs;

            if (!TryCalculateDConnectorMotifs(graph, dMinimum, dMaximum, backgroundWorker,
                out oDConnectorMotifs))
            {
                return (false);
            }

            oMotifs.AddRange(oDConnectorMotifs);
        }

        if ((motifsToCalculate & Motifs.Clique) != 0)
        {
            ICollection<Motif> oCliqueMotifs;

            if (!TryCalculateCliqueMotifs(graph, nMinimum, nMaximum, backgroundWorker,
                oMotifs, out oCliqueMotifs))
            {
                return (false);
            }

            oMotifs.AddRange(oCliqueMotifs);
        }

        return (true);
    }