Suite

Comment diviser une ligne en segments d'une longueur donnée dans cartodb?

Comment diviser une ligne en segments d'une longueur donnée dans cartodb?


Comment puis-je diviser une (poly)ligne en segments d'une longueur donnée dans cartodb ?

Je veux pouvoir visualiser des segments de rue, chacun de 4 m de long, suivant la courbe de la route. Une façon aurait été de tracer le bord de la route avec une ligne puis de la couper en morceaux de 4m.

Je ne peux pas utiliser une simple "grille", car les 4m doivent être tangents au chemin, et je n'ai pas trouvé de moyen de créer des points ou des lignes à une distance donnée les uns des autres.

Cela semble possible dans QGIS et OpenJump (Comment diviser une ligne tous les x mètres ?) mais je ne trouve pas de moyen de le faire dans cartodb.

Toute suggestion?


cartodb utilise postgres/postgis pour que vous puissiez faire de belles requêtes SQL. Je n'ai pas pu essayer, mais celui-ci ci-dessous devrait vous aider : diviser la chaîne de lignes en lignes plus petites


En général, construire une liste en utilisant une boucle de la forme

… serait mieux écrit en utilisant une compréhension de liste.

Chaque intervalle a toujours deux éléments : une heure de début et une heure de fin. Ces listes à deux éléments seraient mieux représentées sous forme de tuples au lieu de listes. (Les tuples ont une connotation qu'ils ont une longueur fixe, alors que les listes peuvent atteindre des longueurs arbitraires.)

Enfin, j'emballerais le code dans une fonction.

Voici quelques suggestions.

Écrire une fonction

Votre code peut être déplacé seul dans une fonction. Il a l'avantage de donner au code un nom clair, une entrée claire, une sortie claire et on pourrait aller plus loin et ajouter de la documentation et des tests.

Structure de données appropriée

Vous retournez une liste de liste. En Python, il existe une différence culturelle dans la façon dont le tuple et la liste sont utilisés.

Dans notre cas, nous savons que chaque pièce contiendra 2 informations : le début et la fin. Il serait plus pertinent d'utiliser des tuples ici.

Tout d'abord, vous devriez être en mesure de voir que la valeur de gauche dans chaque partie est la même que la valeur de droite dans la partie précédente. Cela peut être mis en œuvre en utilisant la recette par paires :

À partir de là, vous devriez être capable de générer tous les nombres souhaités à l'aide d'une liste ou d'un générateur de compréhension :

Tout d'abord, vous pouvez utiliser le troisième paramètre de range , qui est le pas, SI vous pouvez garantir que part_duration est un entier (ce qui est le cas pour l'exemple que vous avez posté ici) :

Notez cependant qu'il ne s'agit que d'une transformation d'une plage en une liste. Si vous transformez une collection en liste, les compréhensions de liste devraient vous venir à l'esprit :

Si vous ne pouvez pas garantir des étapes entières, je ne suis pas sûr d'un bon moyen. Malheureusement, Python n'autorise pas les pas fractionnaires pour sa plage .


3 réponses 3

Si on vous donne un rapport pour une ligne, alors la ligne est divisée en segments, dont les longueurs sont dans le rapport donné. Par exemple, si vous aviez le rapport $2:3$, vous avez raison de penser que la ligne peut s'échelonner sur des segments de $2$, chacun de longueur $2$ et $3$. Évidemment, le total est de 5$ donc ils s'élèvent chacun à $frac<2><5>$ et $frac<3><5>$ de la longueur totale.

Mais si on vous donne une fraction, cela devrait représenter la quantité de la longueur $total$ utilisée. Par exemple, $frac<2><5>$ est une longueur de 2$ sur une longueur totale de 5$ et $pas$ un total de 7$.

D'après mon expérience, les ratios ne sont pas donnés aussi souvent que les fractions et je préfère de loin les fractions.

De plus, jj172 a raison de dire que $2:3$ n'est pas $frac<2><3>$.

Je ne sais pas si je comprends exactement ce que vous demandez, mais j'espère que les informations suivantes pourront vous aider.

Votre hypothèse initiale selon laquelle le rapport 2:3 est égal à 2/3$ est fausse. En fait, le ratio 2:3 signifie que, sur un total de $2+3=5$ objets, il y en a 2 de l'un et 3 de l'autre.

Ainsi, étant donné un rapport, vous additionnez les deux nombres pour obtenir la valeur totale, puis prenez chaque partie du rapport (par exemple 2 et 3 dans le rapport 2:3) et utilisez ce nombre sur le total pour obtenir la fraction équivalente .

Il y a 5 $ + 3 = 8 $ (ou un multiple de 8) objets au total. Ensuite, 5/8$ du nombre total d'objets est le premier type, et 3/8$ du nombre total d'objets est le deuxième type.


Diviser (chaîne, chaîne, options d'expression régulière)

Divise une chaîne d'entrée en un tableau de sous-chaînes aux positions définies par un modèle d'expression régulière spécifié. Les options spécifiées modifient l'opération de correspondance.

Paramètres

Le modèle d'expression régulière à rechercher.

Une combinaison au niveau du bit des valeurs d'énumération qui fournissent des options pour la correspondance.

Retour

Des exceptions

Une erreur d'analyse d'expression régulière s'est produite.

options n'est pas une combinaison de bits valide de valeurs RegexOptions.

Un délai d'attente s'est produit. Pour plus d'informations sur les délais d'attente, consultez la section Remarques.

Remarques

Les méthodes Regex.Split sont similaires à la méthode String.Split(Char[]), sauf que Regex.Split divise la chaîne à un délimiteur déterminé par une expression régulière au lieu d'un ensemble de caractères. La chaîne est divisée autant de fois que possible. Si aucun délimiteur n'est trouvé, la valeur de retour contient un élément dont la valeur est la chaîne d'entrée d'origine.

Le paramètre pattern se compose d'éléments de langage d'expression régulière qui décrivent symboliquement la chaîne à rechercher. Pour plus d'informations sur les expressions régulières, consultez Expressions régulières .NET Framework et Regular Expression Language - Aide-mémoire.

Les expressions régulières compilées utilisées dans les appels aux méthodes Split statiques sont automatiquement mises en cache. Pour gérer vous-même la durée de vie des expressions régulières compilées, utilisez les méthodes d'instance Split.

Si plusieurs correspondances sont adjacentes les unes aux autres, une chaîne vide est insérée dans le tableau. Par exemple, le fractionnement d'une chaîne sur un seul trait d'union amène le tableau renvoyé à inclure une chaîne vide à la position où se trouvent deux traits d'union adjacents.

Si une correspondance est trouvée au début ou à la fin de la chaîne d'entrée, une chaîne vide est incluse au début ou à la fin du tableau renvoyé. L'exemple suivant utilise le modèle d'expression régulière [a-z]+ pour diviser une chaîne d'entrée sur n'importe quel caractère alphabétique majuscule ou minuscule. Étant donné que la chaîne commence et se termine par des caractères alphabétiques correspondants, la valeur du premier et du dernier élément du tableau renvoyé est String.Empty.

Si des parenthèses de capture sont utilisées dans une expression Regex.Split, tout texte capturé est inclus dans le tableau de chaînes résultant. Par exemple, si vous divisez la chaîne "plum-pear" sur un trait d'union placé entre des parenthèses de capture, le tableau renvoyé comprend un élément de chaîne qui contient le trait d'union.

Cependant, lorsque le modèle d'expression régulière inclut plusieurs ensembles de parenthèses de capture, le comportement de cette méthode dépend de la version du .NET Framework. Dans .NET Framework 1.0 et 1.1, si aucune correspondance n'est trouvée dans le premier ensemble de parenthèses de capture, le texte capturé à partir de parenthèses de capture supplémentaires n'est pas inclus dans le tableau renvoyé. À partir du .NET Framework 2.0, tout le texte capturé est également ajouté au tableau renvoyé. Par exemple, le code suivant utilise deux jeux de parenthèses de capture pour extraire les éléments d'une date, y compris les délimiteurs de date, d'une chaîne de date. Le premier ensemble de parenthèses de capture capture le trait d'union et le second ensemble capture la barre oblique. Si l'exemple de code est compilé et exécuté sous .NET Framework 1.0 ou 1.1, il exclut les barres obliques s'il est compilé et exécuté sous .NET Framework 2.0 ou versions ultérieures, il les inclut.

Si l'expression régulière peut correspondre à la chaîne vide, Split divisera la chaîne en un tableau de chaînes à un seul caractère car le délimiteur de chaîne vide peut être trouvé à chaque emplacement.

L'exception RegexMatchTimeoutException est levée si le temps d'exécution de l'opération de fractionnement dépasse le délai d'expiration spécifié pour le domaine d'application dans lequel la méthode est appelée. Si aucun délai d'expiration n'est défini dans les propriétés du domaine d'application, ou si la valeur du délai d'expiration est Regex.InfiniteMatchTimeout, aucune exception n'est levée.

Notes aux appelants

Cette méthode expire après un intervalle égal à la valeur de délai d'expiration par défaut du domaine d'application dans lequel la méthode est appelée. Si une valeur de délai d'attente n'a pas été définie pour le domaine d'application, la valeur InfiniteMatchTimeout, qui empêche la méthode d'expirer, est utilisée. La méthode statique recommandée pour diviser le texte sur une correspondance de modèle est Split(String, String, RegexOptions, TimeSpan), qui vous permet de définir l'intervalle de délai d'attente.

Voir également

S'applique à


Les références

Balaban IJ (1995) Un algorithme optimal pour trouver des intersections de segments. Dans Actes du onzième symposium annuel sur la géométrie computationnelle, p. 211-219

Ben-Moshe B, Dvir A, Segal M, Tamir A (2012) Calcul Centdian dans les graphes de cactus. J Gr Algorithms Appl 16(2):199-224

Bentley JL, Ottmann TA (1979) Algorithmes pour rapporter et compter les intersections géométriques. IEEE Trans Computers 9:643-647

Bose P, Maheshwari A, Morin P, Morrison J, Smid M, Vahrenhold J (2007) Algorithmes de division et de conquête géométriques à efficacité spatiale. Calcul Geom 37(3):209-227

Brévilliers M, Chevallier N, Schmitt D (2007) Triangulations d'ensembles de segments de droite dans le plan. Dans Conférence internationale sur les fondements de la technologie logicielle et de l'informatique théorique, p. 388-399

Brimkov B (2017) Sur des ensembles de segments de ligne présentant une structure de cactus. Dans Atelier international sur l'analyse combinatoire d'images, p. 30-39

Brimkov B, Hicks IV (2017) Algorithmes à mémoire efficace pour les graphes de cactus et les graphes de blocs. Mathématiques discrètes appliquées 216:393–407

Brimkov VE (2013) Problèmes d'approximabilité de la garde d'un ensemble de segments. Int J Mathématiques 90(8) : 1653–1667

Brimkov VE, Leach A, Mastroianni M, Wu J (2011) Garder un ensemble de segments de ligne dans l'avion. Theor Computer Sci 412(15):1313-1324

Brimkov VE, Leach A, Wu J, Mastroianni M (2012) Algorithmes d'approximation pour un problème de couverture d'ensemble géométrique. Mathématiques Appliquées Discrètes 160:1039-1052

Chan TM, Chen EY (2010) Algorithmes en place et sans cache optimaux pour les enveloppes convexes 3D et l'intersection de segments 2D. Calcul Geom 43(8):636-646

Chazelle BM (1983) Rapport et comptage d'intersections planes arbitraires. Rapport CS-83-16, Département d'informatique, Brown University, Providence, RI, États-Unis

Chen EY, Chan TM (2003) Un algorithme efficace en espace pour l'intersection de segments de ligne. Dans: Actes de la 15e conférence canadienne sur la géométrie computationnelle, p. 68-71

Cornuéjols G, Naddef D, Pulleyblank WR (1983) Les graphes de Halin et le problème du voyageur de commerce. Programme de mathématiques 26(3) : 287-294

Dujmović V, Eppstein D, Suderman M, Wood DR (2007) Dessins de graphes planaires avec peu de pentes et de segments. Calcul Geom 38(3):194-212

de Castro N, Cobos FJ, Dana JC, Márquez A, Noy M (2002) Graphes planaires sans triangle et graphes d'intersection de segments. J Gr Algorithms Appl 6(1):7–26

Durocher S, Mondal D (2018) Dessiner des triangulations planes avec peu de segments. Calcul Geom 77:40-45

Eppstein D (2016) Reconnaissance simple des graphes de Halin et de leurs généralisations. J Gr Algorithms Appl 20(2):323-346

Francis MC, Kratochvíl J, Vyskočil T (2012) Représentation par segment d'une sous-classe de graphes coplanaires. Mathématiques discrètes 312(10) : 1815–1818

Green B, Tao T (2013) Sur des ensembles définissant quelques lignes ordinaires. Calcul discret Geom 50(2):409-468

Harary F, Uhlenbeck G (1953) Sur le nombre d'arbres Husimi : I. Proc Nat Acad Sci 39:315-322

Horton SB, Parker RG (1995) Sur les sous-graphes et supergraphes de Halin. Mathématiques discrètes appliquées 56(1):19-35

Husimi K (1950) Note sur la théorie de Mayers des intégrales d'amas. J Chem Phys 18:682-684

Igamberdiev, A, Meulemans W, Schulz A (2015) Dessiner des graphes cubiques planaires 3-connectés avec peu de segments : algorithmes et expériences. Dans Symposium international sur le dessin de graphes et la visualisation de réseaux, p. 113–124

Kára J, Kratochvíl J (2006) Traçabilité des paramètres fixes d'un ensemble indépendant dans les graphiques d'intersection de segments. Dans Atelier international sur le calcul paramétré et exact, p. 166-174

Kariv O, Hakimi SL (1979) Une approche algorithmique des problèmes de localisation de réseau. I : le p-centre. SIAM J Appl Math 37(3):513-538

Koontz WLG (1980) Évaluation économique d'alternatives de secours aux circuits d'alimentation en boucle. Bell Syst Tech J 59(3):277-281

Kumar CP (2019) Sur les régions formées par les diagonales d'un polygone convexe. arXiv:1904.04065

Mairson HG, Stolfi J (1988) Rapporter et compter les intersections entre deux ensembles de segments de ligne. Dans : Earnshaw RA (ed) Fondements théoriques de l'infographie et de la CAO. Springer, Berlin, pp 307-325

Oliveros D, O'Neill C, Zerbib S (2020) La géométrie et la combinatoire des hypergraphes à segments de droite discrets. Mathématiques discrètes 343(6):111825

Poonen B, Rubinstein M (1998) Le nombre de points d'intersection faits par les diagonales d'un polygone régulier. SIAM J Mathématiques discrètes 11 (1) : 135-156

Preparata F, Shamos MI (2012) Géométrie computationnelle : une introduction. Springer, New York

Rappaport D, Imai H, Toussaint GT (1990) Calcul de circuits simples à partir d'un ensemble de segments de ligne. Calcul discret Geom 5(3):289-304

Samee MAH, Alam MJ, Adnan MA, Rahman MS (2008) Dessins de segments minimum de graphiques série-parallèle avec le degré trois maximum. Dans Symposium international sur le dessin graphique, p. 408-419

Sysło MM, Proskurowski A (1983) Sur les graphes de Halin. Dans : Théorie des graphes, Springer, Berlin, pp 248-256

Tiernan JC (1970) Un algorithme de recherche efficace pour trouver les circuits élémentaires d'un graphe. Commun ACM 13:722-726

Vahrenhold J (2007) Intersection ligne-segment réalisée sur place. Calcul Geom 38:213-230

Wagner K (1936) Bemerkungen zum Vierfarbenproblem. Jahresbericht der Deutschen Mathematiker-Vereinigung 46:26-32


Contenu

Le concept de base de la longueur provient de la distance euclidienne. En géométrie euclidienne, une ligne droite représente la distance la plus courte entre deux points. Cette ligne n'a qu'une longueur. Sur la surface d'une sphère, elle est remplacée par la longueur géodésique (également appelée longueur du grand cercle), qui est mesurée le long de la courbe de surface qui existe dans le plan contenant les deux extrémités et le centre de la sphère. La longueur des courbes de base est plus compliquée mais peut aussi être calculée. En mesurant avec des règles, on peut approximer la longueur d'une courbe en additionnant la somme des droites qui relient les points :

L'utilisation de quelques lignes droites pour approximer la longueur d'une courbe produira une estimation inférieure à la longueur réelle lorsque des lignes de plus en plus courtes (et donc plus nombreuses) sont utilisées, la somme se rapproche de la longueur réelle de la courbe. Une valeur précise de cette longueur peut être trouvée en utilisant le calcul, la branche des mathématiques permettant le calcul de distances infiniment petites. L'animation suivante illustre comment une courbe lisse peut se voir attribuer une longueur précise de manière significative :

Toutes les courbes ne peuvent pas être mesurées de cette manière. Une fractale est, par définition, une courbe dont la complexité change avec l'échelle de mesure. Alors que les approximations d'une courbe lisse tendent vers une valeur unique à mesure que la précision de mesure augmente, la valeur mesurée pour une fractale ne converge pas.

Comme la longueur d'une courbe fractale diverge toujours jusqu'à l'infini, si l'on mesurait un littoral avec une résolution infinie ou presque infinie, la longueur des plis infiniment courts du littoral s'additionnerait à l'infini. [5] Cependant, ce chiffre repose sur l'hypothèse que l'espace peut être subdivisé en sections infinitésimales. La valeur de vérité de cette hypothèse - qui sous-tend la géométrie euclidienne et sert de modèle utile dans la mesure quotidienne - est une question de spéculation philosophique et peut ou non refléter les réalités changeantes de "l'espace" et de la "distance" au niveau atomique ( environ l'échelle du nanomètre). Par exemple, la longueur de Planck, de plusieurs ordres de grandeur plus petite qu'un atome, est proposée comme la plus petite unité mesurable possible dans l'univers.

Les côtes sont moins définies dans leur construction que les fractales idéalisées telles que l'ensemble de Mandelbrot, car elles sont formées par divers événements naturels qui créent des motifs de manière statistiquement aléatoire, tandis que les fractales idéalisées sont formées par des itérations répétées de séquences simples et stéréotypées. [6]

Peu de temps avant 1951, Lewis Fry Richardson, en recherchant l'effet possible de la longueur des frontières sur la probabilité de guerre, a remarqué que les Portugais ont déclaré que leur frontière mesurée avec l'Espagne était de 987 km, mais que les Espagnols l'ont signalée à 1214 km. Ce fut le début du problème du trait de côte, qui est une incertitude mathématique inhérente à la mesure de limites irrégulières. [7]

La méthode prédominante pour estimer la longueur d'une frontière (ou d'un trait de côte) consistait à établir m segments rectilignes égaux de longueur avec intercalaires sur une carte ou une photographie aérienne. Chaque extrémité du segment doit être sur la limite. En étudiant les écarts dans l'estimation des frontières, Richardson a découvert ce que l'on appelle maintenant « l'effet Richardson » : la somme des segments est inversement proportionnelle à la longueur commune des segments. En effet, plus la règle est courte, plus la frontière mesurée est longue. Les géographes espagnols et portugais utilisaient simplement des règles de longueurs différentes.

Le résultat le plus étonnant pour Richardson est que, dans certaines circonstances, comme se rapproche de zéro, la longueur du trait de côte se rapproche de l'infini. Richardson avait cru, sur la base de la géométrie euclidienne, qu'un littoral approcherait d'une longueur fixe, tout comme des estimations similaires de figures géométriques régulières. Par exemple, le périmètre d'un polygone régulier inscrit dans un cercle se rapproche de la circonférence avec un nombre croissant de côtés (et une diminution de la longueur d'un côté). Dans la théorie de la mesure géométrique, une courbe lisse comme le cercle qui peut être approximée par de petits segments droits avec une limite définie est appelée une courbe rectifiable.

Mesurer un littoral Modifier

Plus d'une décennie après que Richardson ait terminé ses travaux, Benoit Mandelbrot a développé une nouvelle branche des mathématiques, la géométrie fractale, pour décrire des complexes non rectifiables dans la nature comme le littoral infini. [8] Sa propre définition de la nouvelle figure servant de base à son étude est : [9]

j'ai inventé fractale de l'adjectif latin fracturé. Le verbe latin correspondant frangère signifie « casser : » pour créer des fragments irréguliers. C'est donc judicieux. cela, en plus de "fragmenté" . fracturé devrait également signifier "irrégulier".

Une propriété clé de la fractale est l'auto-similitude, c'est-à-dire qu'à n'importe quelle échelle, la même configuration générale apparaît. Un littoral est perçu comme des baies alternant avec des promontoires. Dans la situation hypothétique où un littoral donné possède cette propriété d'auto-similitude, alors quelle que soit l'agrandissement d'une petite section de littoral, un modèle similaire de petites baies et de promontoires superposés à de plus grandes baies et promontoires apparaît, jusqu'au grains de sable. À cette échelle, le littoral apparaît comme un fil momentanément mouvant, potentiellement infiniment long, avec un arrangement stochastique de baies et de promontoires formés à partir des petits objets à portée de main. Dans un tel environnement (par opposition aux courbes douces) Mandelbrot affirme [8] « la longueur du littoral s'avère être une notion insaisissable qui glisse entre les doigts de ceux qui veulent la saisir.

Il existe différents types de fractales. Un trait de côte avec la propriété déclarée est dans « une première catégorie de fractales, à savoir les courbes dont la dimension fractale est supérieure à 1 ». Cette dernière déclaration représente une extension par Mandelbrot de la pensée de Richardson. La déclaration de Mandelbrot sur l'effet Richardson est : [10]

où L, longueur du littoral, fonction de l'unité de mesure, , est approximée par l'expression. F est une constante et D est un paramètre qui, selon Richardson, dépend du trait de côte approximé par L. Il n'a donné aucune explication théorique mais Mandelbrot a identifié D avec une forme non entière de la dimension de Hausdorff, plus tard la dimension fractale. En réarrangeant le côté droit de l'expression, on obtient :

où Fε −D doit être le nombre d'unités ε nécessaires pour obtenir L. La dimension fractale est le nombre de dimensions du chiffre utilisé pour approximer la fractale : 0 pour un point, 1 pour une ligne, 2 pour un carré. D dans l'expression est compris entre 1 et 2, pour des côtes typiquement inférieures à 1,5. La ligne brisée mesurant la côte ne s'étend pas dans une direction et ne représente pas une zone, mais est intermédiaire. Il peut être interprété comme une ligne épaisse ou une bande de largeur 2ε. Les côtes plus brisées ont un D plus grand et donc L est plus long pour le même . Mandelbrot a montré que D est indépendant de ε.


Envelopper cela dans un script pour le faire en boucle ne serait pas difficile.

Attention, si vous essayez de calculer le nombre d'itérations en fonction de la durée de sortie d'un appel ffprobe, c'est estimé à partir du débit binaire moyen au début du clip et de la taille du fichier du clip à moins que vous ne donniez l'argument -count_frames, ce qui ralentit considérablement son fonctionnement.

Une autre chose à savoir est que la position de l'option -ss sur la ligne de commande est importante. Là où je l'ai maintenant, c'est lent mais précis. La première version de cette réponse a donné l'alternative rapide mais inexacte. L'article lié décrit également une alternative généralement rapide mais toujours précise, que vous payez avec un peu de complexité.

Tout cela mis à part, je ne pense pas que vous vouliez vraiment couper à exactement 10 minutes pour chaque clip. Cela mettra des coupures en plein milieu des phrases, voire des mots. Je pense que vous devriez utiliser un éditeur ou un lecteur vidéo pour trouver des points de coupure naturels à un peu moins de 10 minutes d'intervalle.

En supposant que votre fichier soit dans un format que YouTube peut accepter directement, vous n'avez pas besoin de réencoder pour obtenir des segments. Transmettez simplement les décalages de point de coupure naturels à ffmpeg , en lui disant de transmettre l'A/V encodé à travers intact en utilisant le codec "copy":

L'argument -c copy lui indique de copier tous les flux d'entrée (audio, vidéo et potentiellement d'autres, tels que les sous-titres) dans la sortie tels quels. Pour les programmes A/V simples, cela équivaut aux drapeaux plus détaillés -c:v copy -c:a copy ou aux drapeaux à l'ancienne -vcodec copy -acodec copy . Vous utiliseriez le style le plus détaillé lorsque vous souhaitez copier un seul des flux, mais réencoder l'autre. Par exemple, il y a de nombreuses années, il y avait une pratique courante avec les fichiers QuickTime pour compresser la vidéo avec de la vidéo H.264 mais laisser l'audio comme PCM non compressé si vous rencontriez un tel fichier aujourd'hui, vous pouvez le moderniser avec -c:v copy - c:a aac pour retraiter uniquement le flux audio, en laissant la vidéo intacte.

Le point de départ de chaque commande ci-dessus après la première est le point de départ de la commande précédente plus la durée de la commande précédente.


Normes liées à l'IETF

Ken Gray , Thomas D. Nadeau , dans Network Function Virtualization , 2016

Routage des paquets source dans la mise en réseau

Le groupe de travail SPRING se concentre sur l'insertion d'un chemin explicite ou « routed source » dans l'en-tête de transport de paquets et sur les mécanismes de traversée de chemin.

Étant donné que le routage de segment pour IPv4 utilise la mécanique d'étiquette MPLS pour suivre le chemin de transport, il ne satisfait pas l'objectif NSH de préservation du chemin. Les tentatives d'ajout de métadonnées à une pile de transport MPLS seraient également confrontées à plusieurs défis. 17 Segment Routing for IPv6 (SRv6), 18 cependant, préserve le chemin et a été démontré (dans IETF90 19 ) comme pouvant être utilisé dans SFC.

La proposition SRv6 20 introduit un nouveau type d'en-tête de routage IPv6 (très proche du RFC2460, mais avec des modifications pour le rendre plus flexible et sécurisé). Le nouvel en-tête (SRH) n'est inspecté qu'à chaque saut de segment, il est transparent pour les périphériques non capables qui n'effectuent que le transfert IPv6 sur la trame.

L'en-tête (Fig. 4.12) se compose d'un certain nombre de champs de gestion, d'une liste de segments, d'une liste de politiques et du HMAC.

Graphique 4.12. Le format d'extension d'en-tête SRv6.

L'en-tête suivant indique le type d'en-tête qui suit immédiatement SRH.

La longueur d'en-tête est un entier non signé de 8 bits qui correspond à la longueur de l'en-tête en unités de 8 octets.

Le type de routage doit être attribué par l'IANA.

Segments Left est l'index dans la liste des segments (et fonctionne de manière similaire au SI dans SFC), pointant sur le segment actuellement actif.

Le premier segment est un décalage dans le SRH (sans compter les 8 premiers octets) en unités de 16 octets pointant vers le dernier segment de la liste des segments (qui est en fait le premier segment du chemin).

Les drapeaux se composent d'un champ de 16 bits divisé en quatre drapeaux individuels (chacun 1 bit) : C—nettoyage, P—protégé (utilisé conjointement avec FRR), 2 bits sont réservés et les bits restants vont aux drapeaux de politique. Les indicateurs de politique sont utilisés pour indiquer/définir le type d'adresses IPv6 conservées/codées dans la liste de politiques. Ces 12 bits sont subdivisés en quatre (4) champs de 3 bits pour représenter le contenu des segments 1 à 4 de la liste de stratégies. Les valeurs définies sont : 0x0—Non présent, 0x1—Entrée SR, 0x2—Sortie SR et 0x3—Original Adresse source.

Les champs HMAC sont utilisés pour la sécurité et sont définis dans un projet séparé. 21

La liste de segments est une série d'adresses IPv6 128 bits codées dans l'ordre inverse dans lequel elles seraient traversées dans le chemin (par exemple, la dernière est en position 0 et la première est en position « n »/dernière).

La liste des stratégies, comme indiqué dans la section Indicateur ci-dessus, est une liste facultative d'adresses IPv6 128 bits qui peuvent être utilisées pour diverses opérations de débogage et liées aux stratégies.

La liste de segments a également été envisagée comme étant utilisée en conjonction avec MPLS, où chaque segment pourrait représenter jusqu'à quatre étiquettes de 32 bits.

Les mécanismes de transmission sont illustrés à la Fig. 4.13 . Les transactions sont affichées de manière linéaire, mais les nœuds individuels peuvent être placés arbitrairement dans le réseau avec des redirecteurs IPv6 intermédiaires non compatibles SRH (le projet montre une topologie plus complexe).

Graphique 4.13 . Exemple de transfert SRv6. Par souci de concision, l'en-tête IPv6 complet n'est pas affiché (pas plus que tous les champs d'en-tête SRH).

Dans la figure, l'hôte A envoie à l'hôte F. Grâce à un certain nombre de mécanismes potentiels, B est programmé pour imposer le SRH aux paquets dans un tel flux (A aurait pu également imposer le SRH). La liste de segments que B doit imposer est « C, D, E », ce qu'elle fait conformément à la spécification dans l'ordre inverse. Les segments de gauche et les premiers segments sont définis "m – 1” (2), où N est le nombre de segments (3). L'adresse de destination d'origine dans l'en-tête IPv6 est remplacée par l'adresse du premier segment et est placée à la fin de la liste des segments. Les drapeaux sont définis sur C (propre). Les indicateurs de politique et les segments de politique pourraient être définis pour refléter le nœud SR d'entrée/sortie (comme dans le projet), mais cela n'est pas affiché.

Au fur et à mesure que le paquet progresse, les nœuds compatibles SRF échangeront l'adresse dans les segments restants avec l'adresse de destination IPv6 et décrémenteront les segments restants. Lorsque le paquet arrive à E, le segment suivant sera « 0 ». Avec le bit propre défini, E remplacera l'adresse de destination de l'en-tête IPv6 par F indiquant la destination d'origine et supprimera l'en-tête.

Une démonstration

À l'IETF90, Cisco Systems, l'École Polytechnique (Paris), l'UCL (LLN, Belgique) et Comcast ont collaboré sur une démonstration utilisant des implémentations SRv6 interopérables pour une application spécifique appelée mise en cache hiérarchique.

Dans le cas d'utilisation (illustré à la Fig. 4.14), le contenu d'une vidéo codée en MPEG-DASH est codé en morceaux (de courte durée). Ces morceaux spécifiques sont adressés IPv6 dans le manifeste de la vidéo (où l'adresse est utilisable comme mécanisme de recherche de stockage cohérent, par exemple, hachage). Lorsque l'utilisateur fait une demande de contenu, une liste de segments qui représente une série d'adresses anycast, chacune représentant un niveau dans une hiérarchie de cache et se terminant par le maître de contenu, est imposée dans le cadre d'un en-tête SRv6 au niveau du premier nœud en amont du fournisseur. depuis le décodeur (sur la base d'un match de classement).

Graphique 4.14. Application de mise en cache hiérarchique utilisant SRv6.

Lorsque le paquet TCP/SYN atteint chaque niveau de la hiérarchie du cache dans le chemin, le cache effectue une recherche dans son magasin de contenu (en utilisant une valeur de clé basée sur la valeur de segment la plus interne 22). Si le contenu existait, répondez avec l'ACK approprié pour que la session soit établie, sinon le paquet progresserait vers le prochain niveau de cache le plus élevé par le mécanisme SRv6. Au niveau le plus élevé du système de cache, le maître de contenu, le morceau doit toujours être disponible à un décalage correspondant à cette adresse de morceau.

Les mécanismes d'amorçage du cache ou d'optimisation du cache sont restés inchangés pendant l'essai, de sorte qu'au fil du temps, le cache de niveau le plus bas a été rempli.

Suivant pour SRv6

Bien que SRv6 ait été initialement conçu comme un mécanisme d'ingénierie du trafic, l'utilisation de SRv6 dans la démonstration de l'IETF montre comment SRv6 peut être utilisé pour une application de chaînage de services très spécifique.

Les raisons de la résistance à la réaffectation des en-têtes de transport pour avoir une importance dans l'encodage des métadonnées pour le chaînage de services, sont liées à la quantité variable, limitée d'espace par encapsulation et aux problèmes d'interopérabilité que cela pourrait créer dans les réseaux qui mélangent l'encapsulation dans leurs superpositions (d'où le besoin de transport indépendance). 23 Ceux-ci sont toujours présents dans l'utilisation de SRv6 (même s'il y a sans doute beaucoup plus d'espace pour travailler avec le SRH que d'autres encapsulations). La méthodologie ne peut pas non plus être appliquée directement au trafic IPv4, qui présente un niveau de discontinuité qui devrait être résolu pour que SRv6 soit considéré comme un protocole SFC.

En guise de dernière réflexion sur SRv6, il est clair qu'il devra se coordonner étroitement avec SFC pour éviter la dissolution dans des solutions spécifiques au transport. C'est-à-dire pour éviter la tendance à ces comportements évoquée au début de la section SFC de ce chapitre qui aurait pu condamner SFC à l'échec dès le départ. Les auteurs des projets SRv6 et NSH s'efforcent de normaliser leurs approches en matière de transmission de métadonnées et de rationalisation du chemin de transport vers le SP, ce qui, espérons-le, fait avancer les choses dans la bonne direction. Seul le temps nous dira si cela continue, mais nous espérons que ce sera le cas.


Comment définir la condition pour diviser les sommets sur les sommets d'angle et sans angle ? [fermé]

Vous voulez améliorer cette question ? Ajoutez des détails et clarifiez le problème en éditant ce message.

J'ai un graphe non orienté avec $n<100$ sommets. Le graphique est simple. Les coordonnées de tous les sommets sont connues et fixées $(x_i, y_i) in mathbf$ , $i=1, 2,ldots, n$ , l'ensemble des arêtes est prédéfini, ce sont des segments de droite de longueur $1$ unité. Le degré des sommets peut être $2$ , $3$ ou $4$ .

Sur l'esquisse ci-dessous, les sommets $4$ et $5$ ont le degré $3$ , tandis que les sommets restants ont le degré $2$ .

Question. Comment diviser l'ensemble de tous les sommets dont le degré est égal à $2$ en deux ensembles ? Le premier ensemble doit inclure les sommets d'angle $<1, 3, 6, 8>$ , et le second ensemble doit inclure les sommets autres que d'angle $<2, 7, 9>$ .

Ma tentative. Soit le sommet $i$ le sommet d'angle si son degré est de $2$ et que deux arêtes incidentes ne se trouvent pas sur la même ligne.

On peut sélectionner le sommet $i$ de degré $2$ et calculer l'angle $alpha$ entre les deux arêtes incidentes $e_1$ et $e_2$ , si $alpha == 180$ alors on peut dire que $i$ - le sommet est le sommet sans coin, sinon c'est le sommet du coin.


Prenez $f:[0,1] ightarrow mathbb f(x)=gauche<egin 0 & x eq 1 1 & x=1 enddroite. $ Et $f_n=x^n$ Avec la mise à l'échelle et les définitions par morceaux, vous pouvez utiliser celui-ci pour tout ensemble dénombrable de $c_1,dots ,c_n$ En général, notre fonction ressemblera à $f(x)=left< commencer 0 & x eq c_i forall i 1 & ext finir ight.$ Sur $[c_i,c_]$ nous allons avoir quelque chose comme $f_(x)=gauche(frac ight)^n +left(frac ight)^n$

And all together we will have (with $I=[a,b]$) $f_n(x)=left< egin 0 & xin [a,c_0) f_ & x in [c_i,c_) 0& xin [c_n,b] end ight. $

Edit for a given function the idea is the following, as you only have finite $c_i$ you take with $varepsilon=min_ <1leq i leq n-1><>)>$ which is the shortest distance between two points of incontinuousity. Edit we don't need Stone Weierstraß at all sry.
$[c_i+frac<2n>,c_-frac<2n>]$ we just take $f$ on the intervalls (the uniform convergence is trivial). So we only need to chose a secquence of function on $[c_i-frac<2n>,c_i+frac<2n>]$. We will call them $s_$ (like spline).
We chose $s_(x)= left< egin f(c_i) + frac<2n> ight)-f(c_i)><2n>> cdot (x-c_i) & x-c_i leq 0 f(c_i)+frac<2n> ight)-f(c_i)><2n>>cdot (x-c_i) & x-c_i >0 end ight.$ Ok that one looks really complicated but all i am saying we make a line from the left end to the point we want to have $f(c_i)$ and another one to get a continuous function in all the intervall.


6 Answers 6

To determine when to split the rope, you must look at the area that the rope covers each frame. What you do is you do a collision check with the area covered and your level geometry. The area that a swing covers should be an arc. If there is a collision, you need to make a new segment to the rope. Check for corners that collide with the swinging arc. If there are multiple corners that collide with the swing arc, you should pick the one where the angle between the rope during the previous frame and the collision point is the smallest.

The way you do the collision detection is that for the root of the current rope segment, O, the rope's end position on the previous frame, A, the rope's end position on the current frame, B, and each corner point P in a polygonal level geometry, you calculate (OA x OP), (OP x OB) and (OA x OB), where "x" represents taking the Z coordinate of the cross product between the two vectors. If all three results have the same sign, negative or positive, and the length of OP is smaller than the length of the rope segment, the point P is within the area covered by the swing, and you should split the rope. If you have multiple colliding corner points, you'll want to use the first one that hits the rope, meaning the one where the angle between OA and OP is the smallest. Use dot product to determine the angle.

As for joining segments, do a comparison between the previous segment and the arc of your current segment. If the current segment has swung from left side to the right side or vice versa, you should join the segments.

For the math for joining segments we'll use the attachment point of the previous rope segment, Q, as well as the ones we had for the splitting case. So now, you'll want to compare the vectors QO, OA and OB. If the sign of (QO x OA) is different from the sign of (QO x OB), the rope has crossed from left to right or vice versa, and you should join the segments. This of course can also happen if the rope swings 180 degrees, so if you want the rope to be able to wrap around a single point in space instead of a polygonal shape, you might want to add a special case for that.

This method of course does assume that you are doing collision detection for the object hanging from the rope, so that it doesn't end up inside the level geometry.

It's a while since I played Worms, but from what I remember - when the rope wraps around things, there's only one (straight) section of rope that's moving at any one time. The rest of the rope becomes static

So there's very little actual physics involved. The active section can be modelled as a single stiff spring with a mass on the end

The interesting bit will be the logic for splitting/joining inactive sections of the rope to/from the active section.

I'd imagine there'd be 2 main operations:

'Split' - The rope has intersected something. Split it at the intersection into an inactive section and the new, shorter, active section

'Join' - The active rope has moved into a position where the nearest intersection no longer exists (this may just be a simple angle/dot product test?). Rejoin 2 sections, creating a new, longer, active section

In a scene constructed from 2D polygons, all split points should be at a vertex on the collision mesh. Collision detection may simplify down to something along the lines of 'If the rope passes over a vertex on this update, split/join the rope at that vertex?

Check out how the ninja rope in Gusanos was implemented:

  • The rope acts like a particle until it attaches to something.
  • Once attached, the rope just applies a force onto the worm.
  • Attaching to dynamic objects (like other worms) is still a TODO: in this code.
  • I can't recall if wrapping around objects/corners is supported.

Relevant excerpt from ninjarope.cpp:

I'm afraid I can't give you a concrete algorithm off the top of my head, but it occurs to me that there are only two things that matter for detecting a collision for the ninja rope: any and all potentially colliding vertices on obstacles within a radius of the last "split" equal to the remaining length of the segment and the current direction of swing (clockwise or counter clockwise). If you created a temporary list of angles from the "split" vertex to each of the nearby vertices, your algorithm would just need to care if your segment was about to swing past that angle for any given vertex. If it is, then you need to do a split operation, which is easy as pie -- It's just a line from the last split vertex to the new split, and then a new remainder is calculated.

I think only the vertices matter. If you're in danger of hitting a segment between vertices on an obstacle, then your normal collision detection for the guy hanging at the end of the rope should kick in. In other words, your rope is only ever going to "snag" on corners anyway, so the segments between won't matter.

Sorry I don't have anything concrete, but hopefully that gets you where you need to be, conceptually, to make this happen. :)

Here's a post which has links to papers about similar types of simulations (in engineering/academic contexts rather than for games): https://gamedev.stackexchange.com/a/10350/6398

I've tried at least two different approaches to collision detection+response for this sort of "wire" simulation (as seen in the game Umihara Kawase) at least, I think this is what you're after -- there doesn't seem to be a specific term for this sort of simulation, I just tend to call it "wire" rather than "rope" because it seems like most people consider "rope" to be synonymous with "a chain of particles". And, if you want the stick-ish behaviour of ninja rope (i.e it can push AND pull), this is sort of more like a rigid wire than a rope. Anyway..

Pekuja's answer is good, you can implement continuous collision detection by solving for the time when the signed area of the three points is 0.

(I can't fully recall OTOH but you can approach it as follows: find the time t when point a is contained in line passing through b,c, (I think I did this by solving for when dot(a-b,c-b) = 0 to find values of t), and then given a valid time 0<=t<1, find the parametric position s of a on the segment bc, i.e a = (1-s)b + sc and if a is between b and c (i.e if 0<=s<=1) it's a valid collision.

AFAICR you can approach it the other way around too (i.e solve for s and then plug this in to find t) but it's a lot less intuitive. (I'm sorry if this doesn't make any sense, I don't have time to dig up my notes and it's been a few years!))

So, you can now calculate all the times at which events happen (i.e rope nodes should be inserted or removed) process the earliest event (insert or remove a node) and then repeat/recurse until there are no more events between t=0 and t=1.

One warning about this approach: if the objects that the rope can wrap around are dynamic (especially if you're simulating them AND their effects on the rope, and vice-versa) then there can be problems if those objects clip/pass through each other -- the wire can become tangled. And it will definitely be challenging to prevent this sort of interaction/movement (the corners of objects slipping through each other) in a box2d-style physics simulation.. small amounts of penetration between objects is normal behaviour in that context.

(At least.. this was a problem with one of my implementations of "wire".)

A different solution, which is much more stable but which misses some collisions in certain conditions is to just use static tests (i.e don't worry about ordering by time, just recursively subdivide each segment in collision as you find them), which can be a lot more robust -- the wire won't tangle at corners and small amounts of penetration will be fine.

I think Pekuja's approach works for this too, however there are alternate approaches. One approach I've used is to add auxiliary collision data: at each convex vertex v in the world (i.e the corners of shapes which the rope can wrap around), add a point u forming the directed line segment uv, where u is some point "inside the corner" (i.e inside the world, "behind" v to calculate u you can cast a ray inward from v along its interpolated normal and stop some distance after v or before the ray intersects with an edge of the world and exits the solid region. Or, you can just manually paint the segments into the world using a visual tool/level editor).

Anyway, you now have a set of "corner linesegs" uv for each uv, and each segment ab in the wire, check if ab and uv intersect (i.e static, boolean lineseg-lineseg intersection query) if so, recurse (split the lineseg ab into av and vb, i.e insert v), recording which direction the rope bent at v. Then for each pair of neighbouring linesegs ab,bc in the wire, test if the current bend direction at b is the same as when b was generated (all of these "bend direction" tests are just signed-area tests) if not, merge the two segments into ac (i.e remove b).

Or maybe I merged and then split, I forget -- but it definitely works in at least one of the two possible orders! :)

Given all the wire segments calculated for the current frame, you can then simulate a distance constraint between the two wire endpoints (and you can even involve the interior points, i.e the contact points between the wire and the world, but that's a bit more involved).

Anyway, hopefully this will be of some use. the papers in the post I linked too should also give you some ideas.


Voir la vidéo: Kuidas valida autorehve? @Kuidas??? TV