标签: depth

我有以下递归代码,在每个节点我调用sql查询以获取属于父节点的节点.

这是错误:

Exception RuntimeError: 'maximum recursion depth exceeded' in <bound method DictCursor.__del__ of <MySQLdb.cursors.DictCursor object at 0x879768c>> ignored

RuntimeError: maximum recursion depth exceeded while calling a Python object
Exception AttributeError: "'DictCursor' object has no attribute 'connection'" in <bound method DictCursor.__del__ of <MySQLdb.cursors.DictCursor object at 0x879776c>> ignored

我调用以获取sql结果的方法:

def returnCategoryQuery(query, variables={}):
    cursor = db.cursor(cursors.DictCursor);
    catResults = [];
    try:
        cursor.execute(query, variables);
        for categoryRow in cursor.fetchall():
            catResults.append(categoryRow['cl_to']);
        return catResults;
    except Exception, e:
        traceback.print_exc();

我实际上对上述方法没有任何问题,但我还是把它放在了正确的问题概述上.

递归代码:

def leaves(first, path=[]):
    if first:
        for elem in …

背景:我正在使用最小构造算法构建一个代表字典的trie.输入列表是4.3M utf-8字符串,按字典顺序排序.生成的图形是非循环的,最大深度为638个节点.我的脚本的第一行将递归限制设置为1100 sys.setrecursionlimit().

问题:我希望能够将我的trie序列化到磁盘,因此我可以将其加载到内存中而无需从头开始重建(大约22分钟).我曾经尝试都pickle.dump()和cPickle.dump(),用文本和二进制协议两种.每次,我得到一个如下所示的堆栈跟踪:

  File "/System/Library/Frameworks/Python.framework/Versions/2.5/lib/python2.5/pickle.py", line 649, in save_dict
    self._batch_setitems(obj.iteritems())
  File "/System/Library/Frameworks/Python.framework/Versions/2.5/lib/python2.5/pickle.py", line 663, in _batch_setitems
    save(v)
  File "/System/Library/Frameworks/Python.framework/Versions/2.5/lib/python2.5/pickle.py", line 286, in save
    f(self, obj) # Call unbound method with explicit self
  File "/System/Library/Frameworks/Python.framework/Versions/2.5/lib/python2.5/pickle.py", line 725, in save_inst
    save(stuff)
  File "/System/Library/Frameworks/Python.framework/Versions/2.5/lib/python2.5/pickle.py", line 286, in save
    f(self, obj) # Call unbound method with explicit self
  File "/System/Library/Frameworks/Python.framework/Versions/2.5/lib/python2.5/pickle.py", line 648, in save_dict
    self.memoize(obj)
RuntimeError: maximum recursion depth exceeded

我的数据结构相对简单: trie包含对开始状态的引用,并定义了一些方法. dfa_state包含布尔字段,字符串字段和从标签到状态的字典映射.

我对内部工作原理并不十分熟悉pickle- …

我想知道如何将tar文件的内容列出到某种程度？

我理解tar tvf mytar.tar将列出所有文件,但有时我只希望看到某些级别的目录.

同样,对于该命令ls,如何控制将显示的子目录级别？默认情况下,它只显示直接子目录,但不会更进一步.

kinect中的深度相机有多精确？

• 范围？
• 解析度？
• 噪声？

特别是我想知道:

• 微软是否有任何关于它的官方规范？
• 有关于这个问题的科学论文吗？
• TechBlogs的调查？
• 个人实验很容易重现？

我现在正在收集大约一天的数据,但大多数作者都没有说出他们的来源,而且价值似乎差别很大......

我已经构建了一个必须在大约5M页面上运行的爬虫(通过增加URL ID),然后解析包含"我需要"信息的页面.

在使用在网址(200K)上运行的算法并保存了好的和坏的结果后,我发现我浪费了很多时间.我可以看到有一些返回的减数我可以用来检查下一个有效的URL.

你可以很快地看到减数(少数第一个"好身份证") -

510000011 # +8
510000029 # +18
510000037 # +8
510000045 # +8
510000052 # +7
510000060 # +8
510000078 # +18
510000086 # +8
510000094 # +8
510000102 # +8
510000110 # etc'
510000128
510000136
510000144
510000151
510000169
510000177
510000185
510000193
510000201

在抓取大约200K网址之后,这给了我14K的好结果我知道我浪费时间并且需要优化它,所以我运行一些统计数据并构建了一个函数来检查网址,同时增加id为8\18\17\8(顶部返回减数)等'.

这是功能 -

def checkNextID(ID):
    global numOfRuns, curRes, lastResult
    while ID < lastResult:
        try:
            numOfRuns += 1
            if numOfRuns % 10 == 0:
                time.sleep(3) # sleep every 10 iterations
            if isValid(ID + 8): …

我想创建一个深度优先搜索,我有点成功.

这是我到目前为止的代码(除了我的构造函数,请注意Vertex和Edge类只包含属性,这里没有重要的内容):

private Stack<Vertex> workerStack = new Stack<Vertex>();
private List<Vertex> vertices = new List<Vertex>();
private List<Edge> edges = new List<Edge>();

private int numberOfVertices;
private int numberOfClosedVertices;
private int visitNumber = 1;

private void StartSearch()
{
    // Make sure to visit all vertices
    while (numberOfClosedVertices < numberOfVertices && workerStack.Count > 0)
    {
        // Get top element in stack and mark it as visited
        Vertex workingVertex = workerStack.Pop();
        workingVertex.State = State.Visited;

        workingVertex.VisitNumber = visitNumber;
        visitNumber++;

        numberOfClosedVertices++;

        // Get all edges connected to …

假设我们有这个词:

d = {'a':1, 'b': {'c':{}}}

了解它的嵌套深度最简单的方法是什么？

我想允许嵌入HTML,但由于深度嵌套的HTML文档导致某些浏览器崩溃,因此避免使用DoS.我希望能够容纳99.9%的文档,但拒绝那些嵌套太深的文档.

两个密切相关的问题:

1. 浏览器内置了哪些文档深度限制？例如,浏览器X无法解析或无法构建深度>某些限制的文档.
2. 网上提供文件的文件深度统计数据？是否存在具有Web统计信息的站点,该站点解释了Web上的某些百分比的真实文档的文档深度小于某个值.

文档深度定义为1 +从文档中的任何节点到达文档根目录所需的最大父遍历数.例如,在

<html>                   <!-- 1 -->
  <body>                 <!-- 2 -->
    <div>                <!-- 3 -->
      <table>            <!-- 4 -->
        <tbody>          <!-- 5 -->
          <tr>           <!-- 6 -->
            <td>         <!-- 7 -->
              Foo        <!-- 8 -->

由于文本节点"Foo"具有8个祖先,因此最大深度为8.这里的祖先是非严格的解释,即永远的节点是它自己的祖先和它自己的后代.

Opera有一些表嵌套统计信息,这表明99.99%的文档的表嵌套深度小于22,但该数据不包含整个文档深度.

编辑:

如果人们想批评HTML清理库而不是回答这个问题,请这样做. http://code.google.com/p/owasp-java-html-sanitizer/wiki/AttackReviewGroundRules介绍了如何查找代码,在哪里找到可以尝试攻击的测试平台,以及如何报告问题.

编辑:

我问Adam Barth,他非常友好地指出了处理这个问题的webkit代码.

至少Webkit强制执行此限制.当TreeBuilder作为被创建它接收一棵树的限制,可以配置:

m_treeBuilder(HTMLTreeBuilder::create(this, document, reportErrors, usePreHTML5ParserQuirks(document), maximumDOMTreeDepth**(document)))

Run Code Online (Sandbox Code Playgroud)

并通过块嵌套测试进行测试.

我正在使用一个数据集,其中包含图像,其中每个像素是一个16位无符号int,以mm为单位存储该像素的深度值.我试图通过执行以下操作将其可视化为灰度深度图像:

cv::Mat depthImage; 
depthImage = cv::imread("coffee_mug_1_1_1_depthcrop.png", CV_LOAD_IMAGE_ANYDEPTH | CV_LOAD_IMAGE_ANYCOLOR ); // Read the file 
depthImage.convertTo(depthImage, CV_32F); // convert the image data to float type   
namedWindow("window");
float max = 0;
for(int i = 0; i < depthImage.rows; i++){
    for(int j = 0; j < depthImage.cols; j++){
        if(depthImage.at<float>(i,j) > max){
            max = depthImage.at<float>(i,j);
        }
    }   
}
cout << max << endl;


float divisor = max / 255.0;
cout << divisor << endl;
for(int i = 0; i < depthImage.rows; i++){
    for(int j …

正如标题所说,我想通过使用相邻像素的叉积来计算给定深度图像的表面法线.我想使用Opencv并避免使用PCL,但是我并不真正理解这个过程,因为我的知识在这个主题上非常有限.因此,如果有人可以提供一些提示,我将不胜感激.这里要提到的是除了深度图像和相应的rgb图像之外我没有任何其他信息,所以没有K相机矩阵信息.

因此,假设我们有以下深度图像:

并且我想在相应的点找到具有相应深度值的法向量,如下图所示:

如何使用相邻像素的叉积来做到这一点？我不介意法线是否高度准确.

谢谢.

更新:

好吧,我试图关注@ timday的答案并将他的代码移植到Opencv.使用以下代码:

Mat depth = <my_depth_image> of type CV_32FC1
Mat normals(depth.size(), CV_32FC3);

for(int x = 0; x < depth.rows; ++x)
{
    for(int y = 0; y < depth.cols; ++y)
    {

        float dzdx = (depth.at<float>(x+1, y) - depth.at<float>(x-1, y)) / 2.0;
        float dzdy = (depth.at<float>(x, y+1) - depth.at<float>(x, y-1)) / 2.0;

        Vec3f d(-dzdx, -dzdy, 1.0f);
        Vec3f n = normalize(d);

        normals.at<Vec3f>(x, y) = n;
    }
}

imshow("depth", depth / 255);
imshow("normals", normals);

我得到正确的结果如下(我不得不更换double …