detection

I have implemented a small cycle detection algorithm for a DAG in Scala. The 'return' bothers me - I'd like to have a version without the return...possible? def isCyclic() : Boolean = { lock.readLock().lock() try { nodes.foreach(node => node.marker = 1) nodes.foreach(node => {if (1 == node.marker && visit(node)) return true}) } finally { lock.readLock().unlock() } false } private def visit(node: MyNode): Boolean = { node.marker = 3 val nodeId = node.id val children = vertexMap.getChildren(nodeId).toList.map(nodeId => id2nodeMap(nodeId)) children.foreach(child => { if (3 == child.marker || (1 =

I need to find the architecture type of a CPU. I do not have access to /proc/cpuinfo, as the machine is running syslinux. I know there is a way to do it with inline ASM, however I believe my syntax is incorrect as my variable iedx is not being set properly. I'm drudging along with ASM, and by no means an expert. If anyone has any tips or can point me in the right direction, I would be much obliged. static int is64Bit(void) { int iedx = 0; asm("mov %eax, 0x80000001"); asm("cpuid"); asm("mov %0, %%eax" : : "a" (iedx)); if ((iedx) && (1 << 29)) { return 1; } return 0; } tyranid How many bugs can

I'm implementing a peak detection algorithm in Python that detects only those peaks that are above a threshold magnitude. I don't want to use the inbuilt function as I have to extend this simulation to Hardware implementation also. from math import sin,isnan from pylab import * def peakdet(v, delta,thresh,x): delta=abs(delta) maxtab = [] mintab = [] v = asarray(v) mn, mx = v[0], v[0] mnpos, mxpos = NaN, NaN lookformax = True for i in arange(len(v)): this = v[i] if abs(this)>thresh: if this > mx: mx = this mxpos = x[i] if this < mn: mn = this mnpos = x[i] if lookformax: if (this < mx-delta): if

I am trying to detect the eyes' irises but HoughCircles returns 0 circles. The input image(eyes) is: Then I made the following things with this image: cvtColor(eyes, gray, CV_BGR2GRAY); morphologyEx(gray, gray, 4,cv::getStructuringElement(cv::MORPH_RECT,cv::Size(3,3))); threshold(gray, gray, 0, 255, THRESH_OTSU); vector<Vec3f> circles; HoughCircles(gray, circles, CV_HOUGH_GRADIENT, 2, gray.rows/4); if (circles.size()) cout << "found" << endl; So the final gray image looks like this: I've found this question Using HoughCircles to detect and measure pupil and iris but it didn't help me despite

This question is about an algorithm for determining the number and location of maxima in a sequence of numbers. Thus, there is a statistical flavor to the question, but it is more leaning towards programming, because I am not interested in the specific statistical properties, and the solution needs to be in R. The use of statistics to answer this question is OK, but not a requirement. I want to extract maxima of cycles in time series data (i.e., an ordered sequence of numbers). An example of such data is the solar flare time series (~11 year cycle, between 9 & 14 years). The cycles don't

My colleague and I have to develop and implement an application on an Android tablet for a company. We started and almost completed the development of the application in question using the Eclipse AVD (we hadn't recieved the tablet yet) and it works perfectly. We received the tablet on which the application must be installed, the model: SynchroDigital INOSOP10-4.0 RES, 10" with ICS, less than 100 €, the really cheap one. Our problem: my PC doesn't recognize the tablet (WIN7, unable to install drivers when connecting, although I've already successfully developed on Galaxy S and Galaxy Tab). I

I have a bit noisy image where the background is not homogeneous. The image contains brigther convex spots, and I need to detect them. Here's a link for an example image: I know there is a lot of circle detection algorithm, but the difference between the environment and the object is too small. Do you any suggestion, how to segment the brigther spot? Or any idea to increase the intensity difference between them? update: the OpenCV environment is C++. I tried the adaptive threshold with many parameters. Here's the result: It is not bad, but the image contains a lot of other black spots. And