u/ES-Alexander

The sub has a wiki, with heaps of recommended resources:

https://www.reddit.com/r/learnpython/wiki/index/

It can do, although it does depend on how the OCR system was designed/trained.

Many OCR models are intended for recognising characters in photographs (rather than screenshots), and may get extra information out of having a slight gradient at the edges of the characters (instead of being single value regions).

The Fathom-X is an interfacing board (that handles connections and filtering) with an included LX200V20 daughter board (that handles the HomePlug conversion).

The LX200V20 by itself is understandably cheaper than a plug and play product, especially given the costs involved with engineering, manufacturing, packaging, and distribution. The more of that load which can be taken on (or avoided), the lower the final cost will be, and the design is open source (so there’s minimal extra engineering required for an identical product), but if OP is unable to provide or source the components or manufacturing from elsewhere then there are limited opportunities for cost reduction (short of taking a different approach).

The Fathom-X is the HomePlug adaptor board used by Blue Robotics, and it’s open source if you want to make your own / use the design as a reference instead of buying a pre-made pair.

There are also newer communication interfaces that provide higher bandwidth capacity, but I’m not aware of any existing board designs that are suitable for ROV use, so if you need higher bandwidth (e.g. for several cameras or something) you’d need to design one yourself (or use fiber.

The main relevant discussion I can think of is in mesh exporting, unless OpenSCAD happens to have tooling for nicely/realistically rendering generated models?

I believe the website is from the previous iteration of the project - the Python version has been released for a couple of years now, and is how design work is generally expected to be done (because there’s much more flexibility available in code than predefined spreadsheets or web interfaces).

If I’m remembering correctly several of the Jupyter notebook examples/tutorials make use of the visualise package, although I’ve been out of the loop for a while - I just know it exists because I developed some of it 😅

The main README does include some suggestions for the development environment :-)

I expect most users use the visualize subpackage for previews - I suppose that (and an overview of workflow/results) could stand to be better represented in the main readme file, instead of mostly being discussed in the Python package one?

Edit: slicers are another option, but are somewhat awkward because of the general lack of layers.

Given it’s a digital device, the ideal solution would be to connect to it directly through an API and just receive the data it’s measuring.

If there’s no way to connect to it for that kind of access, then next best is to have a fixed position screen, camera, and lighting, in which case you can determine the “characters” quite easily by splitting each image into sections (possibly after some camera calibration and image unwarping), and then determining and grouping the values of the relevant seven-segment display numbers (e.g. using pixel values directly, or template matching). There are presumably libraries/functions that can help with the seven-segment display interpreting if you don’t want to implement it yourself.

If you can’t set the hardware up in a fixed manner, you may need to do some feature matching and perspective warping to get consistent images for the rest of the process.

Replacing black pixels (or near black pixels with a threshold) with white pixels would be pretty straightforward, but may cause contrast issues if there are light-coloured lines or annotations in other parts of the plot that are intended to contrast with the original dark background.

Would it perhaps make sense to just invert the colours of the plot instead?

Some potentially thought-provoking questions:

1. There are two fluids at play here (air and water), and the pump is likely only intended for moving one of them - are you able to keep the pump submerged?
2. If your ballast tank is rigid, can the air inside escape when you pump water in? If so, what happens when you try to pump water back out with less air inside to expand into the space?
3. Is the outside water pressure ever expected to be less than the internal air pressure? If not, do you need a pump for forcing water in, or could a valve setup be sufficient?

You can use a distanceTransform if you need to be precise, but that will be more expensive than a couple of blind convolutions (since you seemed to be concerned about efficiency).

If your smoothing kernel size is <= the size of your dilation kernel then step c) should be redundant, and setting the kernel sizes to be equal should achieve the effect you’re after.

The falloff rate of the gradient is dependent on your smoothing kernel - Gaussian is likely a decent option, but you may also wish to consider linear or other options too.

Are you probing before or after heating the bed? If it’s not warm when probing then the z-offset is also accounting for the thermal expansion of the bed, which may explain the difference.

Is it important to you to create the entire thing in your own self-contained application?

I’d expect it’s more effective to focus on solving the critical part (transcribing audio into notes with durations), in which case perhaps you could develop a plugin for an existing sheet music creation software (MuseScore, maybe?).

How you break down the project depends on what your actual goals are, as well as your existing and learnable skills.

The OpenBB Terminal project is Python-based and open source - I’m unsure how it’s changed since I heard about it a few years ago, but it could potentially be at least a useful reference, if not directly useful to you.

Cool project!

You might be able to find some inspiration from other similar projects, including in the Issues of open source ones (like these mission ideas from BlueSim).

Extending rather than scaling means you likely want to cut the shape along a plane, separate the parts by the extension length, then extrude (or loft) from the flat surfaces you’ve created with the cut, up to the matching faces.

There are various CAD programs you could do that with, and possibly Blender as well. That said, the shape you’ve shown is also simple enough to be created with three basic sketches, two extrudes, a cut, and some fillets, so it may be similarly straightforward to create a new one as modifying the existing one.

There’s already a “Full Page” option for screenshots in several of the built in iOS applications (like safari, notes, etc), and there are some installable apps for more general scrolling screenshot support.

A BlueROV2 can be specced to 300m depth rating, but doing so would cost at least double your suggested price range. There are additional caveats around tether range, and if you want to go deeper you may need some custom parts.

There are a few UK-based Blue Robotics distributors, which might be worth a look (since they may sell modified or alternative vehicles that can go deeper), but unfortunately I don’t expect you’ll be able to meet your desired price.

Look into side-channel attacks in the cybersecurity space - some of them are insane.

Your idea seems maybe plausible in very specific circumstances, but it also seems unlikely that someone has bothered to try to make it happen…

For a limited set of known characters you can use template matching to roll your own OCR if need be.

From memory tesseract by default expects dark text on a light background, and also likes to have soft edges, so you may wish to invert your images and/or add some Gaussian smoothing/blurring. If that’s not sufficient you could do some masking based on known qualities of the text in question - your screenshots seem to consistently show a border of fully black pixels around fully white text, so you could mask out any pixels that aren’t fully white and that don’t have at least one adjacent black pixel to a side or corner.

Given the Swedish source and the colour scheme, it’s very likely something from SAAB, but since it’s from <=2015 it’s probably not a model they sell anymore. You could maybe reach out to them directly? :-)

Thanks for the feedback!

No worries :-)

That’s a cool idea for the 2.0.0!

Haha, maybe a 1.1, since it could still be compatible with the original, but with some new features? If you’re following semantic versioning then 2.0 would be something with breaking changes, and with other versioning systems it would still likely be something major (e.g. making it accessible through a web-API, or expanding the project to allow inputting information about a climb and predicting a grade from that).

Cool idea, and nice work! :-D

A few small suggestions:

• you could avoid some redundancy (and reduce maintenance overhead) by replacing your start/height dictionaries with dataclasses
• for convenience, you might want to consider generating alternate constructors for the Grade class, using the names of each valid grading system (e.g. so you could do YDS("5.14a") > French("8a"), instead of having to type Grade as much)
• it could be nice to use StrEnum in the place of some or all of the plain strings you’re using as enumerations/names, so that linters can warn when invalid values are used (e.g. because of a typo)

Possibly r/askelectronics