Smooth Transition to New E-mail Accounts

Hello, all. :) Sven, I was wondering if there might be a way to add functionality to the e-mails in GSASER, so that existing accounts can be set to use for email verification ONLY.
This way, if I’m planning to begin using a new set of e-mail catch-alls, whatever number of submitted links are out there waiting for e-mail verification can still verify, while just adding in the new e-mail accounts for the purpose of making new links.
I do realize I can just set projects to Verify and wait until the Submitted list is clear on all projects and THEN disable that email account I no longer wish to use, set up a few new ones, and start making new links again, but this might be a smoother transition with a way to limit an email to only be used for verification as links can still be made and nothing is lost.
PS Hope everyone is ok with this virus going on.

How do I continue a smooth stroke around a corner in zBrush?

I have been trying to create a series of smooth lines down the outside of a bell shape, around the lip, and then back up the inside. The problem is that I can’t seem to accomplish this in a single brush stroke, and every time I’ve tried to join up multiple strokes, the join always looks really obvious.

enter image description here

Is there any way to “pause” a stroke so that you can rotate your view, and then resume it smoothly? Or is there any other way in general to go about something like this?

Evenly Spaced Points On Smooth Surface

I want to space points evenly (i.e. maximizing minimal distance between two points) on some smooth surface $ S\subseteq\mathbf{R}^n$ (usually $ n=3$ ), where I have a projection operator $ p:\mathbf{R}^n\to S$ which approximates the closest point on the surface. My idea is to place them randomly first and then let some repelling force act between them and reproject back to the surface after each iteration of the action. This can be rather costly, if there are $ 10^3$ points, I have to compute the distance between $ 10^6$ points in one iterations, and I need a few iteration until everything stabilizes.

How can I imporove this process? My ideas:

  • Measure the distance between every pair of points but compute the force only when the distance is smaller than some $ a$ , then do a few iterations (assuming the points don’t move too far in one iteration) and recompute the distance after $ k$ steps.
  • Choose some partition of the surface where each part has a set of ‘neighbours’ (including itself), compute for each point the location in the partition, i.e. the part it lies in, then let only the points in neighbouring parts act on each other, recompute the location after $ k$ steps.

A Smooth and Round Voronoi Mesh

I want the edges of a VoronoiMesh to be smooth and round. I have found the following code from this answer

arcgen[{p1_, p2_, p3_}, r_, n_] :=   Module[{dc = Normalize[p1 - p2] + Normalize[p3 - p2], cc, th},    cc = p2 + r dc/EuclideanDistance[dc, Projection[dc, p1 - p2]];   th = Sign[      Det[PadRight[{p1, p2, p3}, {3, 3}, 1]]] (\[Pi] -         VectorAngle[p3 - p2, p1 - p2])/(n - 1);   NestList[RotationTransform[th, cc],     p2 + Projection[cc - p2, p1 - p2], n - 1]] roundedPolygon[Polygon[pts_?MatrixQ], r_?NumericQ,    n : (_Integer?Positive) : 12] :=   Polygon[Flatten[    arcgen[#, r, n] & /@      Partition[If[TrueQ[First[pts] == Last[pts]], Most, Identity][pts],       3, 1, {2, -2}], 1]] 

Consider for example, the 3×3 hexagonal mesh (see this question for more details)

L1 = 3; L2 = 3; pts = Flatten[    Table[{3/2 i, Sqrt[3] j + Mod[i, 2] Sqrt[3]/2}, {i, L2 + 4}, {j,       L1 + 4}], 1]; mesh0 = VoronoiMesh[pts]; mesh1 = MeshRegion[MeshCoordinates[mesh0],     With[{a = PropertyValue[{mesh0, 2}, MeshCellMeasure]},      With[{m = 3}, Pick[MeshCells[mesh0, 2], UnitStep[a - m], 0]]]]; mesh = MeshRegion[MeshCoordinates[mesh1],    MeshCells[mesh1, {2, "Interior"}]] 

enter image description here

Using roundedPolygon defined above, I can get what I want with

Graphics[{Directive[LightBlue, EdgeForm[Gray], EdgeThickness -> .001],      roundedPolygon[#, 0.3]} & /@ MeshPrimitives[mesh, 2]] 

enter image description here

This looks good already, but I have the following questions:

  1. Is it possible to fill the gaps between cells automatically? I first thought about setting a Background colour on in Graphics that would match the edge colour. This, however, yields a box look that I want to avoid. I could also change the edge thickness, but this doesn’t seem to scale with the lattice size. Any idea how to solve this? The following picture illustrates these cases.

enter image description here

  1. Is it possible to scale the EdgeThickness with the mesh size?

  2. When I consider a square mesh, given, for example, by pts = Flatten[Table[{i, j}, {i, L2 + 2}, {j, L1 + 2}], 1] and mesh = MeshRegion[MeshCoordinates[mesh0], MeshCells[mesh0, {2, "Interior"}]]

enter image description here

roundedPolygon seems to fail, returning, among others, the error

enter image description here

Any idea how to solve this?

  1. Finally, I wonder if it’s possible to display the mesh as a mesh-type object and avoid using Graphics.

I don’t expect to get an answer to everything, but any ideas or suggestions are welcome.

Smooth animations for multiline text

This is basically what I’m trying to achieve:

I have searched around a lot on the wonderful webb and tried a few Javascript and CSS animation libraries, AOS, animate.css, Velocity.js, without any luck.

I have tried to recreate the animation here –

As you might notice however the animations used here with AOS seems a bit clunky.

Would be tremendously appreciative if someone could point me in the right direction to a library or show some code examples of these kinds of animations! 🙂

Unity 2D: Smooth ease-out movement on grid

I’m trying to create a grid movement in Unity, as where the player will ease-out on a tile when stopping, but I can’t seem to get it right. I need a little nudge in the right direction for how to implement something like this:

Example of how I'd like my movement

I used a coroutine to execute the movement when input is requested and use an ease-out curve to make the player stop smoothly. But, when walking multiple tiles it is jittery because the ease-out is applied. Also, the smoother I want the ease-out to be, the slower the player moves.

protected IEnumerator SmoothMovement(Vector3 endPosition, float duration) {     float elapsed = 0F;     Vector3 startPosition = transform.position;      while (elapsed < duration) {         Vector3 newPosition = Vector3.Lerp(startPosition, endPosition, moveCurve.Evaluate((elapsed/duration)));          rigidBody.MovePosition(newPosition);         elapsed += Time.deltaTime;         yield return null;     } } 

The IEnumerator is called once there’s horizontal or vertical input.

Own movement with high speed

Own movement with low speed and better ease-out

Trying to smooth a scroling animation and understand why my text disappear momentaneously

I’m developping a website to learn a bit more about javascript, css and html. A draft of this website is here :

I’m having some trouble with the scrolling : scrooling up and down triggers an horizontal scroll.

When I’m scrolling down and up with the trackpad on my laptop the animation is quite smooth on Chrome, but horrible on Firefox.

Besides on Chrome the left part of the page tend to disappear momentaneously when I’m scrolling back up.

Here’s the js code I use for the scrolling :

var scroll = 0; var target_page = ""; var round = 0; var speed=50; var timeout = null; var diff = 0;  $  ('.accueil').on('mousewheel DOMMouseScroll', function(e){ if(typeof e.originalEvent.detail == 'number' && e.originalEvent.detail !== 0) {   if(e.originalEvent.detail > 0) {     scroll++;   } else if(e.originalEvent.detail < 0){       scroll--;   } } else if (typeof e.originalEvent.wheelDelta == 'number') {   if(e.originalEvent.wheelDelta < 0) {       scroll++;   } else if(e.originalEvent.wheelDelta > 0) {       scroll--;   } }  if(scroll>0){   round = Math.trunc(scroll/speed);   target_page = '.page:eq('+(numItems-round-2)+')';   $  ('.accueil').css("width", (0.32+0.2*(numItems))*$  (window).innerWidth()+0.3*$  (window).innerWidth()*scroll/speed);   $  ('.accueil').css("left", -0.5*$  (window).innerWidth()*scroll/speed);   $  (target_page).css("width", 0.2*$  (window).innerWidth()*(1+1.5*(scroll/speed-round)));   $  (target_page+' .photo').css("height", -0.01*$  (window).innerHeight()+0.2*$  (window).innerHeight()*(1+1.5*(scroll/speed-round)));   $  (target_page+' .photo').css("width", -0.01*$  (window).innerWidth()+0.2*$  (window).innerWidth()*(1+1.5*(scroll/speed-round)));   if(scroll/speed- round > 0.5){$  (target_page+' .numero').css("color", "#000");}else{$  (target_page+' .numero').css("color", "#eaeaea");}   $  (target_page+' .titre, '+target_page+' .date, '+target_page+' .categorie, '+target_page+' .sous_titre, '+target_page+' .numero').css("margin-left", 0.2*$  (window).innerWidth()*(0.05+1.5*(scroll/speed-round)));    clearTimeout(timeout);      timeout = setTimeout(function() {         if(scroll/speed- round <= 0.5){scroll=round*speed;$  (target_page+' .numero').css("color", "#eaeaea");}         else{scroll=(round+1)*speed;$  (target_page+' .numero').css("color", "#000");};         $  ('.accueil').css("width", (0.32+0.2*(numItems))*$  (window).innerWidth()+0.3*$  (window).innerWidth()*scroll/speed);         $  ('.accueil').css("left", -0.5*$  (window).innerWidth()*scroll/speed);         $  (target_page).css("width", 0.2*$  (window).innerWidth()*(1+1.5*(scroll/speed-round)));         $  (target_page+' .photo').css("height", -0.01*$  (window).innerHeight()+0.2*$  (window).innerHeight()*(1+1.5*(scroll/speed-round)));         $  (target_page+' .photo').css("width", -0.01*$  (window).innerWidth()+0.2*$  (window).innerWidth()*(1+1.5*(scroll/speed-round)));         $  (target_page+' .titre, '+target_page+' .date, '+target_page+' .categorie, '+target_page+' .sous_titre, '+target_page+' .numero').css("margin-left", 0.2*$  (window).innerWidth()*(0.025+1.5*(scroll/speed-round)));      }, 1000); }   else{scroll=0;}      });  

What the code does on scroll is 1) widdening a div 2) and the page 3) and move it horizontally

I would like a cross-browser smooth and efficient transition. Any advice ?

Thanking you in advance.

Coarse underlying curve of a smooth stable curve

In the theory of moduli spaces of smooth stable curves with $ n$ -marked points, I have come across the notion of the coarse underlying curve. Let $ C$ be a smooth stable genus $ g$ curve with $ n$ -marked point. We could give it additional structure such as an $ r$ -spin structure, then there is a natural map to the coarse underlying curve. How is this coarse underlying curve defined and what is this natural map? Is it related to the compactification of the Deligne-Mumford stack or is this something else?

I have not been able to find a definition in any of the papers I am reading. Can someone suggest a reference or give me an intuitive/short description of what this is?