physics – Why does light-colored skin look different in black and white versus digitally desaturated versions of color originals

One friend, who was a photographer, commented that a desaturated photograph of light-skinned people looks like they have a suntan compared to a true black and white picture of the same skin, and further commented that it’s because light-colored skin has more red compared to a grey of the same value, and black and white film does not pick up on red light.

This does not seem to me to make sense; I’d expect the opposite, at least in terms of RGB (should I be applying something else, CYMK or subtractive). If vaguely pinkish skin that gets its color from blood emits more red than blue or green, then flattening out the red and desaturating what’s left, and normalizing value for the fact that a significant amount of light has been removed, then it would appear that light skin would reflect less green and blue, so the algorithm outlined in this paragraph would make light-skinned people look darker than they would in a desaturated color photograph, not lighter.

Also, I’ve had just enough photography in school to know that a black-and-white darkroom can use dim red lights without fogging things, so I don’t think that my friend was wrong to say that red does not register in black-and-white photos.

But in most black-and-white photographs, light-skinned people look like their skin is almost white, more like ivory or possibly lighter than that.

So why does light skin look lighter and not darker when you take a black-and-white picture?

Basic pseudocode to create a rope physics

I am trying to simulate the physics of a 2D hanging rope, consistent of a series of n-links. It could be a series of four pendulums. I just want some movement of the rope and the ability to contact with the ground. I was inspired by this question and this one.

I would like to programme it from zero in Python or a similar modelling program, but I don’t find simple maths to recreate this effects. Which are the basic equations to escalate a series of n-links to resemble like a rope, please?

algebraic topology – Why does it seem possible from Physics to say something about orientability locally?

In Quantum Field Theory, if I understand correctly, Physicists showed that certain process are not symmetric under time reversal. This should be a local thing, mathematically, and would show that spacetime must be time-orientable (otherwise there is a loop after which a particle should be time-reversed). I think something similar can be said about space-orientability (maybe the CPT-Theorem shows that it’s equivalent?).

Sorry about the very non-rigorous question.

unity – 2D physics without “rebound”

I’m trying to get my 2D top down shooter to use -some- physics.

I want the player and enemies not be able to exist in the same position, in other words, use collisions.

My first attempt was to use a CharacterController, but I could not get my other game objects to collide with my player, even though I had a RigidBody2D and a BoxCollider2D on them. Obviously, due to using a CharacterController, I was not able to add these components on my player.

Going one step back, I removed the CharacterController, and rather opted to go the Rigidbody2D route. This worked partially. I now get collisions on my player when he walks into other gameobjects (with RB2D and BC2D on them), but there seems to be a “rebound” anomaly occurring; my player moves around after collision.

I’ve tried playing around with the settings on the RigidBody2D on the player, but it does not seem to have any effect.

I would like my player to stop dead in his tracks when colliding with another RigidBody2D. Is this possible? And if so, how would I go about doing that?

Unity3d- Are there any ways to make Hair physics so realistic that your character can hang upside-down and have their hair fall accordingly?

Everything I’ve been finding so far has decent physics upright, but turns stiff and unnatural when dealing with hanging-upsidedown animations.

What would be the recommended approach for achieving 360degree realistic hair physics movement?

networking – How to deal with race conditions on a game server between network and physics update loops?

I am new to game networking.

In various articles on the internet, I found that there are usually two loops on the server: one for physics updates and the other for sending snapshots to the client (network updates). As I understand, loops can run in parallel, which makes me think they should run on different threads.

Now, in terms of concurrency, physics thread is the writer and the network thread is the reader. Given that the threads can run concurrently, there can be race conditions: reader thread can read inconsistent game state if the writer thread is currently modifying it.

How to deal with this race condition? The crude approach would be just to use lock on the game state, but it seems to me that this will introduce delays. For some reason I can’t find anything on the web.

physics – Problem fitting data

If I have the following data:

Tgexpandlit={{57.8505, 1.36339}, {58.1254, 1.0671}, {58.7645, 0.646116}, {59.221, 
  0.349873}, {60.6788, -0.273668}, {62.7712, -0.803456}, {64.3186, 
-1.28659}, {64.3186, -1.28659}, {66.5927, -1.83193}, {68.7745, 
-2.20572}, {71.0471, -2.57948}, {72.7748, -2.92218}, {74.3203, 
-3.20255}, {76.138, -3.45164}, {78.5006, -3.74739}, {80.2275, 
-3.99651}, {81.4994, -4.12096}, {82.6805, -4.24544}, {83.4074, 
-4.32324}, {84.1346, -4.44783}, {85.1342, -4.57236}, {86.3147, 
-4.61885}, {87.1328, -4.75901}, {88.2229, -4.85232}, {88.859, 
-4.93014}, {90.04, -5.03902}, {91.4019, -5.06986}, {92.2198, 
-5.17884}, {93.4007, -5.28772}, {93.3998, -5.17853}, {94.4905, 
-5.34983}, {96.4889, -5.50529}, {97.3069, -5.62986}, {99.1234, 
-5.75417}, {99.2131, -5.62936}, {99.8498, -5.76958}, {101.848, 
-5.87825}, {101.847, -5.83145}, {102.575, -5.95605}, {103.936, 
-5.98689}, {105.389, -6.0489}, {53.05, 1.02729}, {54.3782, 
  0.553702}, {54.2158, 
  0.0303926}, {56.9221, -0.439578}, {59.0303, -0.956926}, {62.3764, 
-1.42534}, {66.8545, -1.9367}, {69.3497, -2.40747}, {70.7512, 
-2.70496}, {71.6037, -2.92466}, {51.2734, 1.02255}, {52.1209, 
  0.547695}, {52.3608, 
  0.0254565}, {55.4547, -0.443448}, {56.8651, -0.962607}, {59.8218, 
-1.43198}, {65.7229, -1.9396}, {69.0066, -2.40835}, {70.6466, 
-2.70522}, {71.5932, -2.92468}, {54.5032, 1.03115}, {54.9453, 
  0.555205}, {56.6674, 
  0.0368729}, {57.758, -0.437381}, {60.2665, -0.9537}, {62.7824, 
-1.42429}, {66.8842, -1.93663}, {69.7442, -2.40648}, {71.3554, 
-2.70343}, {72.963, -2.92124}, {53.05, 1.02729}, {54.4775, 
  0.553965}, {54.7589, 
  0.0318322}, {58.2357, -0.436128}, {60.1001, -0.954134}, {63.2519, 
-1.42308}, {66.8886, -1.93662}, {69.3662, -2.40743}, {70.8179, 
-2.70479}, {71.7396, -2.92431}, {51.2734, 1.02255}, {52.2206, 
  0.547961}, {52.8968, 
  0.0268856}, {56.701, -0.44016}, {57.9147, -0.959849}, {60.6854, 
-1.42973}, {65.7529, -1.93952}, {69.0215, -2.40831}, {70.7068, 
-2.70507}, {71.7159, -2.92437}, {54.5032, 1.03115}, {55.0455, 
  0.55547}, {57.1738, 
  0.0382057}, {59.0075, -0.434107}, {61.2621, -0.95111}, {63.6165, 
-1.42214}, {66.9159, -1.93655}, {69.7599, -2.40644}, {71.4196, 
-2.70327}, {73.0906, -2.92092}, {51.139, 2.32322}, {52.2163, 
  1.80322}, {53.1749, 1.32866}, {53.6977, 1.02902}, {54.1641, 
  0.808406}, {54.7846, 0.554779}, {55.0134, 0.333536}, {50.6163, 
  2.32182}, {52.0102, 1.80267}, {52.6447, 1.32724}, {53.6972, 
  1.02902}, {54.1492, 0.808367}, {54.1878, 0.553197}, {54.8392, 
  0.333075}, {52.6762, 2.32733}, {53.7473, 1.8073}, {54.0918, 
  1.33109}, {55.3849, 1.03349}, {55.5279, 0.812018}, {55.6434, 
  0.557051}, {55.9373, 0.335978}}

and I am fitting it to a function such as:

   Eappitz = 99.925; q0 = 10/60; Tg0itz = 54.26 + 273.15; Aitz = 
 Log10((Tg0itz^2)/(q0*Eappitz*1000));

(nlm = NonlinearModelFit(
    Tgexpandlit, {((-C11 (T + 273.15 - Tg0itz))/(C22 + (T + 273.15 - 
            Tg0itz))) + Aitz}, {C11, C22}, T)) // Normal

nlm("BestFitParameters")

C1itz = C11 /. nlm("BestFitParameters")(*7.76*);
C2itz = C22 /. nlm("BestFitParameters")(*19.22*);


fitz(T_) := ((-C1itz (T + 273.15 - Tg0itz))/(C2itz + (T + 273.15 - 
        Tg0itz))) + Aitz

I get a very bad fit such as the following:

Show(Plot(fitz(T), {T, -5, 108}, Frame -> True, FrameStyle -> 16, 
  Axes -> False, GridLines -> Automatic, 
  GridLinesStyle -> Lighter(Gray, .8), 
  FrameTicks -> {Automatic, Automatic}, ImageSize -> Large, 
  LabelStyle -> {Black, Bold, 14}, PlotStyle -> Blue, 
  PlotRange -> {All, {-6.4, 6}})
 
 , ListPlot(Tgexpandlit))

Which gives:

enter image description here

However, If I only use the first portion of the same data such as:

Tgexpandlit={{57.8505, 1.36339}, {58.1254, 1.0671}, {58.7645, 0.646116}, {59.221, 
  0.349873}, {60.6788, -0.273668}, {62.7712, -0.803456}, {64.3186, 
-1.28659}, {64.3186, -1.28659}, {66.5927, -1.83193}, {68.7745, 
-2.20572}, {71.0471, -2.57948}, {72.7748, -2.92218}, {74.3203, 
-3.20255}, {76.138, -3.45164}, {78.5006, -3.74739}, {80.2275, 
-3.99651}, {81.4994, -4.12096}, {82.6805, -4.24544}, {83.4074, 
-4.32324}, {84.1346, -4.44783}, {85.1342, -4.57236}, {86.3147, 
-4.61885}, {87.1328, -4.75901}, {88.2229, -4.85232}, {88.859, 
-4.93014}, {90.04, -5.03902}, {91.4019, -5.06986}, {92.2198, 
-5.17884}, {93.4007, -5.28772}, {93.3998, -5.17853}, {94.4905, 
-5.34983}, {96.4889, -5.50529}, {97.3069, -5.62986}, {99.1234, 
-5.75417}, {99.2131, -5.62936}, {99.8498, -5.76958}, {101.848, 
-5.87825}, {101.847, -5.83145}, {102.575, -5.95605}, {103.936, 
-5.98689}, {105.389, -6.0489}}

I now get a great fit like:

enter image description here

Question:

  1. Why cannot use all the data or how can I arrange the data so that all the data can be used to get the fit? (as opposed to only part of the same data)

physics – Can one build a “mechanical” universal turing machine?

This question connects different disciplines so it’s awkward to choose a SE site for it, but I’ll go with this one because here (I hope) the shared culture will make information transfer easier.

So computers as we know them use electricity and I don’t know what other invisible things that I don’t understand. I was wondering, is this a matter of efficiency, or of necessity? Can one achieve universal computation with just “moving parts”? Perhaps “Newtonian physics” is some term for this, although I guess it includes gravity which isn’t really what I mean. You know, just good old solid pieces of matter moving around.

To get some picture of what I mean, here is a “LEGO turing machine”. I’m afraid that the big gray block on top uses electricity, but could one replace it with a “mechanical” thing, powered perhaps by rotating a piece? I have no idea how such things be designed, and the state transitions for a universal TM have to be fairly complicated, so I have no intuition for whether this is possible or not.