nx | sixth rewrite

Your misconception is about "focal length". It's an overloaded term.

• "focal length" (unit mm) in the optical part: it describes the distance between the lens plane and image/sensor plane
• "focal length" (unit pixels) in the camera matrix: it describes a scale factor for mapping the real world to a picture of a certain resolution

1750 may very well be correct, if you have a high resolution picture (Full HD or something).

The calculation goes:

f [pixels] = (focal length [mm]) / (pixel pitch [µm / pixel])

(take care of the units and prefixes, 1 mm = 1000 µm)

Example: a Pixel 4a phone, which has 1.40 µm pixel pitch and 4.38 mm focal length, has f = ~3128.57 (= fx = fy).

Another example: A Pixel 4a has a diagonal Field of View of approximately 77.7 degrees, and a resolution of 4032 x 3024 pixels, so that's 5040 pixels diagonally. You can calculate:

f = (5040 / 2) / tan(~77.7° / 2)

f = ~3128.6 [pixels]

And that calculation you can apply to arbitrary cameras for which you know the field of view and picture size. Use horizontal FoV and horizontal resolution if the diagonal resolution is ambiguous. That can happen if the sensor isn't 16:9 but the video you take from it is cropped to 16:9... assuming the crop only crops vertically, and leaves the horizontal alone.

Why don't you need the size of the chessboard squares in this code? Because it only calibrates the intrinsic parameters (camera matrix and distortion coefficients). Those don't depend on the distance to the board or any other object in the scene.

If you were to calibrate extrinsic parameters, i.e. the distance of cameras in a stereo setup, then you would need to give the size of the squares.

I use NX everyday on a mac with M1 chip and i never had such problems.

I think you should better use the last version of NX available with this tutorial on the NX website : NestJS with NX

This benchmark shows the performance of many graphs libraries (from different languages). It confirms NetworkX is very slow. The graph-tool Python package seems a significantly faster alternative to NetworkX. Please note that the performance of a given package is dependent of what you want to achieve because the performance of a graph algorithm is very dependent of the chosen internal representation.

Check first if adding nrwl/cli would help, as shown here:

https://en.cppreference.com/w/cpp/named_req/StandardLayoutType

A standard layout type requires all data members be in the same type.

Standard layout is conservative in definition. Additional types could be made standard layout. The fact that a type is not standard layout doesn't mean there is a good reason that it isn't. It just means the standard committee and compilers haven't done the work to justify it. I mean, you could make classes with virtual functions standard layout if the committee really wanted (like, standardize how vtables work).

One concern is that the committee doesn't want to needlessly break existing code. So they try to standardize existing practice unless there is a good reason. If two compilers disagree on layout of a class, that makes standardizing their layout more costly and/or generate less benefits.

Standard layout is technically just a flag; semantically it means different compilers with similar options (like packing) are going to compile compatible data layouts.

It looks like, in calculate_community_modularity, you use greedy_modularity_communities to create a dict, modularity_dict, which maps a node in your graph to a community. If I understand correctly, you can take each subgraph community in modularity_dict and pass it into shannon_entropy to calculate the entropy for that community.

this is pseudo code, so there may be some errors. This should convey the principle, though.

after running calculate_community_modularity, you have a dict like this, where the key is each node, and the value is that which the community belongs to

You can first aggregate the pandas tables to have a weight column, and then load it to networkx with that edge column:

Reason of the issue

It is expected browserslist to return an entry for each version ("safari 15.2", "safari 15.3") instead of a range ("safari 15.2-15.3"). So, this is just a bug in the parsing logic of Safari browser versions which needs to be corrected and will be done soon in fixed versions of Angular 12/Angular 13. Link to details is here.

IMPORTANT UPDATE:

This is fixed in v12.2.16 and v13.2.1, please update if you are experiencing this issue. Users on v11 shouldn't be affected. Link to details is here. If you can not/do not want to update for any reason, then one of the workarounds below can be used.

Workarounds:

Modify .browserslistrc

Add to .browserslistrc such lines:

The reason why the edge weights are plotted is that the weights are not updated after removing a node. Hence, pos and labels in your script should be recalculated after removing the node: