Question: i'm trying to filer an array of this Object:

MyObject.h

```
@interface MyObject : NSObject

@property (assign) int id_object;
@property (nonatomic, strong) NSString *name;

@end

```

So for example in my firstArray i have some MyObject:

```
MyObject *ob1 = [[MyObject alloc] init];
[ob1 setId_Object:1;
[ob1 setName:@"Carl"];

MyObject *ob2 = [[MyObject alloc] init];
[ob2 setId_Object:2;
[ob2 setName:@"Carl"];

MyObject *ob3 = [[MyObject alloc] init];
[ob3 setId_Object:3;
[ob3 setName:@"Carl"];

NSArray *firstArray = [[NSArray alloc] initWithObjects:ob1,ob2,ob3,nil];

```

then i want filter this array with NSPredicate with an array of NSNumber, like this:

```
NSArray *secondArray = [NSArray arrayWithObjects:[NSNumber numberWithInt:1],[NSNumber numberWithInt:2],nil];

```

i have tried this:

```
 NSArray *filteredObject = [firstArray filteredArrayUsingPredicate:[NSPredicate predicateWithFormat:@"id_object IN %@",secondArray]];

```

but the filteredObject is empty, how i can do?

Answer: 
If you equate the world origin (0,0,0) with the camera focus (center of projection as you call it) *and* you assume the camera is pointing along the positive z-axis, then the situation looks like this in the plane x=0:

![Diagram of cameral world coordinates](https://i.stack.imgur.com/Xk7pI.png) 

Here the axes are z (horizontal) and y (vertical). The subscript `v` is for "viewport" or screen, and `w` is for world. 

If I get your meaning correctly, you know `h`, the screen height in pixels. Also, `zw`, `yv` and `xv`. You want to know `yw` and `xw`. Note this calculation has (0,0) in the center of the viewport. Adjust appropriately for the usual screen coordinate system with (0,0) in the upper left corner. Apply a little trig:

```
tan(43/2) = (h/2) / f = h / (2f),  so f = h / ( 2 tan(43/2) )

```

and similar triangles

```
yw / zw = yv / f            also              xw / zw = xv / f

```

Solve:

```
yw = zw * yv / f            and                xw = zw * xv / f

```

Note this assumes the "focal length" of the camera is equal in the x-direction. It doesn't have to be. For best accuracy in `xw`, you should recalculate with `f = w / 2 tan(57/2)` where `w` is the screen width. This is because `f` isn't a true focal length. It's just a constant of conversion. If the pixels of the camera are square and optics have no aberrations, these two `f` calculations will give the same result.

**NB:** In a deleted (improper) article the OP seemed to say that it isn't zw that's known but the length D of the hypotenuse: origin to (xw,yw,zw). In this case just note `zw = D * f / sqrt(xv² + yv² + f²)` (assuming camera pixels are square; some scaling is necessary if not). They you can proceed as above.
i cannot add comment since i have a too low reputation here.
But I remind that the camera angle of the kinect isn't general the same
like in a normal photo camera, due to the video stream format and its sensor chip. Therefore the SDK mentioning 57 degrees and 43 degrees, might refer to different degree resolution for hight and width.

it sends a bitmap of 320x240 pixels and those pixels relate to

```
Horizontal FOV: 58,5° (as distributed over 320 pixels horizontal)
Vertical FOV: 45,6° (as distributed over 240 pixels vertical).

```

Z is known your angle is known, so i supose law of sines can get you proper locations then <https://en.wikipedia.org/wiki/Law_of_sines>