标签: intersection

我有两个代理集.有找到的功能:

1. 两个(交叉点)中存在的代理的代理集
2. 代理的代理集,存在于一个而不是另一个中

我发现手动实现这一点非常困难,特别是在需要三重内部时 ask

理想的用法类似于with语法:

let cross set1 and-in set2
let uniq set1 with [color = red] not-in set2

简单的事情,例如"代理集X中的代理A？" 是有问题的

在我的机器上(Quad core,8gb ram),运行Vista x64 Business,使用Visual Studio 2008 SP1,我试图非常快地交叉两组数字.

我在C++中实现了两种方法,在C#中实现了一种方法.到目前为止,C#方法更快,我想改进C++方法,因此它比C#更快,我希望C++可以做到.

这是C#输出:(发布版本)

Found the intersection 1000 times, in 4741.407 ms

以下是两种不同方法(Release x64 build)的初始C++输出:

Found the intersection (using unordered_map) 1000 times, in 21580.7ms
Found the intersection (using set_intersection) 1000 times, in 22366.6ms

这是最新的C++输出,有三种方法(Release x64 build):

最新基准:

Found the intersection of 504 values (using unordered_map) 1000 times, in 28827.6ms
Found the intersection of 495 values (using set_intersection) 1000 times, in 9817.69ms
Found the intersection of 504 values (using unordered_set) 1000 times, in 24769.1ms

因此,set_intersection方法现在比C#慢约2倍,但比初始C++方法快2倍. …

我正在开发一个开源跟踪和地理围栏软件应用程序,并且在确定地理围栏的数学时遇到了一些困难.

我需要确定一个坐标是否存在于多边形内部.然而,棘手的部分是多边形没有设定数量的边.我需要能够计算五十面或五面.

我的研究表明,最简单的方法是取我的观点(我称之为x)和多边形之外的一个点(称之为y)并确定线((xx,xy),(yx,yy))是否与之相交多边形的边界.如果它相交奇数次,则点x必须在多边形内.

但是,知道这一点,我无法弄清楚如何在算法中表达这一点.我显然需要遍历构造多边形的各种线,但是检查确实让我无法理解.有人可以帮忙吗？请知道我不是必须要求解决方案.任何可以帮助我找到答案的东西都是一个巨大的帮助.

非常感激.

我想检查是否(如果是,并且,如果是(x,y),则仅用于突出显示)路径确实与自身相交.如何检查路径是否与另一条路径相交也是非常有趣的.这是一个截图,以更好地解释我的意思:

http://i.stack.imgur.com/JrEmN.png

我想问你是否有任何算法如何最小化图中的边缘交叉,例如,如果我有一个图的转换矩阵.

我找到了尝试将节点放在另一个节点周围的方法,但我想知道其他一些想法.谢谢.

在过去的几天里,我第一次一直在攻击光线跟踪器.然而,有一些困扰我的怪癖,我真的不知道如何解决.从一开始就存在的是场景中球体的形状 - 渲染时,它们实际上看起来像椭圆形.当然,场景中有透视,但最终的形状看起来仍然很奇怪.我附上了一个样本渲染,我所遇到的问题在图像左下角的反射球上特别明显.

我真的不知道是什么原因引起的.它可能是光线球体交叉代码,如下所示:

bool Sphere::intersect(Ray ray, glm::vec3& hitPoint) {
//Compute A, B and C coefficients
float a = glm::dot(ray.dir, ray.dir);
float b = 2.0 * glm::dot(ray.dir, ray.org-pos);
float c = glm::dot(ray.org-pos, ray.org-pos) - (rad * rad);

// Find discriminant
float disc = b * b - 4 * a * c;

// if discriminant is negative there are no real roots, so return
// false as ray misses sphere
if (disc < 0)
    return false;

// compute q
float …

我正在实现一个反向索引结构,特别是允许布尔查询和字级粒度的结构.

我有一个大型的文本数据库,我保留一个索引,告诉我,对于每个单词,它在哪个文件中(IDdoc),以及文件在哪里(position).(一个单词可以在许多文件中,也可以在一个文件中的许多位置.)

因此,我为每个单词保留一个向量:

vector<pair<IDdoc,position>> occurences_of_word;

(向量按IDdoc排序,然后按位置按升序排序.)

我有一个string用文字构成的对象.这是我正在寻找的短语.

对于短语中的每个单词,我想知道哪些文档包含该短语,因此返回s 的向量.IDdoc

这是我尝试解决方案:

typedef std::string     Word_t;
typedef unsigned int    WordPosition_t;
typedef unsigned int    IDdocument_t;

vector<pair<IDdocument_t,WordPosition_t> > IndiceInvertidoBooleanoConPosicion::_interseccion_dos_listas
    (const vector<pair<IDdocument_t,WordPosition_t>> & v1,
    const vector<pair<IDdocument_t,WordPosition_t>> & v2)
{
vector<pair<IDdocument_t,WordPosition_t> > intersection;

IDdocument_t ID_doc_one, ID_doc_two;

int i = 0;
int j = 0;
const int MAX_INDEX_V1 = v1.size() -1;
const int MAX_INDEX_V2 = v2.size() -1;

while(i <= MAX_INDEX_V1  && …

let rec mem list x = match list with
                 | [] -> false
                 | head :: tail -> 
                   if x = list.Head 
                   then true
                   else mem list.Tail x 

函数mem接受一个列表和一个var X作为参数,并检查列表是否包含值X,如果是,则返回true,如果是,则返回false.

let rec intersection list1 list2 = match list1 with
               | head :: tail -> match list2 with 
                     | head :: tail -> if mem list2 list1.Head = true 
                     then (*add the value to a list*) else intersection list1.Tail list2
               | [] -> failwith "Second list is empty"
       | [] -> …

假设您有N组未分类的字符,这些组之间有共同的字符.我想从这些集合中分解出尽可能多的字符以使它们变小.但是将字符分解出来有一个约束:字符必须在你从N中选择的M个集合的交集中.这有点像无损集合压缩算法.以下示例是有序集,但这是为了便于阅读.不要假设将订购套装.

一个简单的例子:

S1 = a b c d
S2 = a b c e f
S3 = a f g

答案是只交叉S1和S2并将因子分解出来:ab c.这会减少6个字符,其中任何其他交集组合将减少.

一个棘手的例子:

S1 = a b c d e f g h i
S2 = j k l m n
S3 = j k l o p q
S4 = j k l
S5 = a b c d

答案是忽略集合S1和S5并将剩余集合S2,S3和S4的交集得到:jk l.

abcd不正确的原因是因为当你将这些字符从集合中分解出来时,剩下19个字符,而当你考虑jk和l out时,只剩下18个字符.

是否有一种算法可以比指数时间更快地解决这类问题？您似乎必须测试集合的幂集中的每个集合的交集({},{S1},{S2},{S3},{S1,S2},{S1,S3},{S2 ,S3},{S1,S2,S3}) - 8个交点来计算是否只有3组.

PS这不是一个紧迫的问题,但我认为这是一个我遇到的有趣问题.

我有很多视图试图拉伸然后相交以创建最终的多边形。问题是结果不是预期的，它有一些浮动的额外部分。我需要以某种方式纠正这个问题，即使解决方案是一种检测这些浮动额外部分并擦除它们的方法。

我正在使用这个库https://www.npmjs.com/package/ Three-csg-ts/v/3.1.10 来进行交集的二进制运算。

我不知道这是一个错误还是我做错了什么。我已经尝试了很多不同的拉伸设置配置，但仍然遇到同样的问题。

我对 js 或 ThreeJS 没有太多经验，所以如果我的代码可读性不好，我很抱歉，我已经尽力了。

import './style.css'
import * as THREE from 'three'
import { OrbitControls } from 'three/examples/jsm/controls/OrbitControls.js'
import { CSG } from 'three-csg-ts'

// Canvas
const canvas = document.querySelector('canvas.webgl')

/**
 * Sizes
 */
 const sizes = {
    width: 1677,
    height: 1287
}

// Scene
const scene = new THREE.Scene()

// View Points
const view_1 = [1019, 516, 1005, 502, 968, 481, 944, 482, 911, 492, 902, 505, 892, 510, 879, 522, 880, …