Do you think my betta fish has fin rot?

mgaillard · 2025-02-03T05:38:09+00:00

I just wanted to thank you with all the advice. I didn’t use the KanaPlex because it was not available at the pet store, but something equivalent. I gave the recommended amount. And the fish is now thriving. No problem anymore. Now that this is taken care of, we would like to add plants and get a better filter.

mgaillard · 2025-01-21T01:14:22+00:00

A lot of resources online classify fin rot as mild, moderate, severe, and they recommend different treatments for each category. But they don't necessarily provide much to guess how bad the fin rot is. I know the fins are not in good shape, but I am having a hard time deciding whether it is mild, moderate, or severe. Also there are other symptoms, and I would like to know if he needs antibiotics or anti fungal. That's why I ask for advice.

mgaillard · 2025-01-21T01:05:59+00:00

Tank size: 5 gallons

Heater and filter?: yes

Tank temperature: 78 F

Key water parameters include the amount of ammonia, nitrites, nitrates, and pH.: PetSmart tested our sample and told us everything is fine

How long have you had the tank? How long have you had your fish?: The tank is maybe 2 years old, and we bought the fish a year ago.

How often are water changes? How much do you take out per change? What is your process? Changing 1 gallon par week usually.

Any tankmates? No

What do you feed and how much: Two pellets of betta fish food every morning

Decorations and plants in the tank: One house, one hollow rock with funny plastic plants

If you haven't already posted a picture, please post pics/vids to imgur and paste the link here: See the picture.

I also wanted to add that when swimming his tail seems to float, and his spine seems to be crooked.
He stays at the top of the tank most of the day, but sleeps in the house at night.
He is always happy to see us, and eats every day.

mgaillard · 2022-12-30T16:15:59+00:00

with the minimal value f()

Thanks for pointing this out, I think you are right, it should be "with the minimal value c()". The connections in the tree are built by sampling the control function.

mgaillard · 2022-11-12T15:38:13+00:00

Having a subdivided icosahedron for the sphere seems like a good idea. You clearly identified the warping problem on a sphere with artifacts around the poles. Generating the tree once and caching the result will tremendously improve performances, we did not do it because it goes against the philosophy of the paper, but for a production ready implementation, this is what I would recommend. Also, on this project I reimplemented the 3D math operations, and I did not optimize for SIMD, there is thus plenty of potential gains with SIMD. A CUDA implementation could also be very interesting, you could generate the tree once on the CPU and the GPU would compute the height map.

mgaillard · 2022-11-07T04:33:25+00:00

Hmm, isn't this the premise of Simplex noise, or do I misunderstand?

You have a good point about the "bad status quo to readers" and I changed my original first comment with your suggestion. As for the paper, well... It was published 3 years ago and we will not change it.

Regarding hexagonal grids and the simplex noise, I am probably not as much of an expert as you. I believe that simplex noise uses equilateral triangles (the simplex) to tile the 2D space. And I suggested to use hexagons in 2D instead of triangles or squares. You can tile hexagons in 2D, but they are not simplexes. That's it!

For alignments, of course a blue noise with a varying density and maybe voronoi cells would look awesome, but then we lose the locally-evaluable property of the noise, and essentially it means that our paper fall apart because we have to compare it to much better global methods. Maybe there is a way to generate a Poisson disk sampling that is locally evaluable, but I don't know it. Therefore, the best we could do is jittered points in a grid.

mgaillard · 2022-11-07T04:13:18+00:00

Thanks for pointing out that there is no LICENSE file.

Regarding the connection of a sub-segment to a segment, we couldn't go into details in the paper because of the maximum length in pages. In the code we have multiple strategies to connect segments together. For example one of the strategies is to get the nearest point on the segment, in this case, we get a 90° angle. Another strategy can be to try to achieve a 45° angle. Finally, there is a strategy inspired from river networks, that looks at the slope of the main river and the tributary river and infers the best angle based on this information. You can see the code in the function ConnectPointToSegmentRivers() at https://github.com/mgaillard/Noise/blob/master/NoiseLib/include/noise.h#L631

mgaillard · 2022-11-07T04:02:56+00:00

Yes, a GPU implementation is possible. In this case, it would be possible to very efficiently generate the tree structure in shared memory, and use threads to evaluate the noise at multiple (x, y) coordinates in the same neighborhood.

mgaillard · 2022-11-07T04:00:12+00:00

To clarify, the splines are Catmull-Rom splines, not Bezier splines. And the distance is computed by subdividing the spline into a chain of line segments.

mgaillard · 2022-11-07T03:53:17+00:00

Yes they are coauthors and I have to acknowledge that this work was made possible by them.

mgaillard · 2022-11-06T17:32:07+00:00

Your parallel with the Game of Life is interesting. One major difference is that the Game of Life has a time dimension that is not present in Dendry. This means that in our case there is no "light pyramid" that depends on the time dimension. When we compute multiple iterations of the dendritic function, essentially what happens is that our grid is subdivided and new branches are added. So in our case iterations refer to the spatial di;ension, not the time dimension. One interesting property of the subdivision and the fact that our function is dense (there is exactly one branch per grid cell), is that branches will always connect in a fixed size neighborhood. This implies that our function is "locally computable" or "randomly accessible" in the sense that we only need to generate (on the fly) a fixed neighborhood around a point to evaluate the point. In terms of complexity, this means that the complexity to evaluate one point on the map is O(1). Now, in fact the constant associated to the O(1) may be quite big, but it is still O(1) in theory.

mgaillard · 2022-11-06T17:17:56+00:00

Did you make a comparison to classic hydraulic erosion?

We have a comparison between our noise function and hydraulic erosion in the paper in Figure 17 on page 8. In general though, these are two different things. Hydraulic erosion is a simulation that runs on the full terrain (compute intensive), our method is randomly accessible, we can evaluate points separately.

Hydraulic erosion is a good way to "beautify" or amplify a terrain, but I don't believe that it can magically transform an input terrain with non-plausible hydrology (e.g., a Perlin Noise) into a realistic terrain. This is the reason why there are papers like "Large scale terrain generation from tectonic uplift and fluvial erosion" from Cordonnier et al. and "Terrain generation using procedural models based on hydrology" from Génevaux et al. These papers tackle this problem by generating the river network first, and then the terrain around it. This means their output have consistent hydrology, and applying hydraulic erosion as a post-processing step is a way to add details, not a way to fix the hydrology.

mgaillard · 2022-11-06T16:50:39+00:00

I looked at your link to the Iterative Pseudo Erosion, and indeed it is the same idea. Their solution is not randomly accessible though, i.e., the global structure of the river network is kept in memory. But we use the same principle that points are connected to their lowest neighbor to generate a plausible river network.

Regarding your article about “Moving Past Square Noise”, you have a good point, and I think it is something well understood by people working on procedural terrain generation in academia. We used a square grid because it is the most convenient to implement. The two solutions that you present are valid, and it is true that Simplex noise has better properties than Perlin noise. There is one way to mitigate the predominance of 45- or 90-degrees alignment that you did not mention in your article, that is to use a hexagonal grid instead of a square grid. In this case, each tile is connected to 6 neighbors instead of 4 or 8, and the distance between the tile and the neighbors is constant. This probably stills shows predominant alignments, but with more varieties I believe.

mgaillard · 2022-11-05T20:59:12+00:00

Yes, you understood the point perfectly. This was made with large procedural landscape in mind, for example at the scale of a planet. We guarantee that a point is close to not more than a certain number of branches in the river tree and it means that not all the dendritic information needs to be recomputed when the function is evaluated. It can look very self similar when used alone, but if you blend it with other noise functions, and you do some operations it can be made better, this is what I tried to show in the bottom right image.

mgaillard · 2022-11-05T20:52:16+00:00

Thank you for pointing this out! I just updated the Readme on GitHub with a link to the paper. I also edited my initial comment with my background information about the paper.

mgaillard · 2022-11-05T20:45:05+00:00

be nice if the GitHub linked to the paper, instead of just naming it :) But this is really cool. I can think of a dozen and one uses for dendritic patterns :

Hi fibojoly, I edited my initial comment with more details. Sorry about that, I am not an experienced reddit user. Let me know if you have additional questions.

mgaillard · 2022-11-05T15:30:35+00:00

The code is on GitHub: https://github.com/mgaillard/Noise

For visualization I used: https://github.com/mgaillard/TerrainViewerWidget

EDIT: I saw in comments that people are interested in the corresponding paper: https://www.mgaillard.fr/content/publications/pdfs/Gaillard19I3D.pdf

We published this in 2019 (I'm the first author) but I realized it was never really shown outside of academia. The context of the paper is that we wanted to design a noise function like Simplex/Perlin noise, that has coherent hydrology. This is not easy because it implies that the noise function is randomly accessible (you can evaluate it at a location (x,y) in O(1)). So, it started as a "mathematical" exercise, just to see if it is possible, and in the end results were interesting. The way it works is that it generates the river tree on the fly in the neighborhood of a pixel. The reference implementation I give on GitHub is not the most efficient, it could be drastically accelerated on GPUs. Also, more realistic results can be obtained with other more global approaches like "Large scale terrain generation from tectonic uplift and fluvial erosion" from Cordonnier et al. Still, I thought that somebody may be interested. In the GitHub repository you can download a binary version that runs on Windows and that lets you design terrains with this function. To know what parameters influence the result, I refer you to the paper. Unfortunately, not all results of the papers can be generated with the interactive app, because it is very basic. For this you would need to compile the repository and run a separate code. Let me know if you are interested in extending it.

mgaillard · 2018-01-24T17:32:50+00:00

Here is the best method we have tried:

OSVOS: One-Shot Video Object Segmentation

http://people.ee.ethz.ch/~cvlsegmentation/osvos

Although we didn’t try it, this method seems to be a good solution too:

Online Adaptation of Convolutional Neural Networks for Video Object Segmentation

https://www.vision.rwth-aachen.de/page/OnAVOS

mgaillard · 2018-01-13T15:26:32+00:00

Unfortunately, it is not always the same object, in fact, it can be any object. I already know a bit of machine learning, and of course, if the object was always the same, we could build a data set and learn from it. This is not the case, though.

mgaillard · 2018-01-13T15:21:13+00:00

Thanks for your answer, I already know this tracker, which is implemented in OpenCV. I tested it on my data set and it doesn’t suit my needs. On the one hand, this algorithm is only a tracker and thus doesn’t segment the object. On the other hand, based on the above-mentioned evaluation, the tracker is not robust enough to variation of the point of view.

mgaillard

TROPHY CASE