## File management – Organize photos for many overlapping projects

I am working with a larger collection of photographs (~ 10,000) for my doctoral thesis (in biology) and I am currently struggling with organizing them. I'm sorry, if this question is in the incorrect stackexchange community, I just thought that if someone here should know about the organization of the photos.

### My collection:

To elaborate a little more about what I would like to achieve:
I am currently doing my PhD work and I need to take many photos to identify or program different plants. As my project is divided into 4 or 5 different subprojects (each with other subdivisions) it is difficult to maintain a general vision. In addition, some images are of general interest to my project and, therefore, should be related not only to the corresponding subproject, but also to the whole. Also, I'm waiting for more photos to accumulate, since this was only the first of the three field seasons …

### My question:

If I am looking for in this forum (for example, here or here) or in any search engine, mostly ideas for everyday life or professional images appear. But these use a type of organization very different from what I need. For example, it is of little use to organize my photos in people, places, events and dates as is frequently suggested (for example, here).

Regarding the folder structure, I thought about sorting the images corresponding to days (for example, `2019-06-23`). But I'm afraid this could be a disaster! Or maybe I could sort images in the subprojects and use tags in the metadata to link them to other subprojects?

### Side notes:

• I'm running a Linux machine (Manjaro, specifically) and so far I tried `DigiKam` For the organization of my library. But I suppose that the operating system only has a secondary importance here (that is, each operating system should have at least some software to solve this type of problem).

• For now I do not need to synchronize my files between devices.

• Usually, I do not need to edit my photos. Only maybe 1-2 for the cover later …

## How to organize the highlighting of a 3D object with which the contact is produced?

I want to repeat a certain "Select (); Deselect ();", as shown in the screenshot.

Ask for advice on how to implement it or what you need to read to implement this function.

PD Screenshot of the game "Recocido"

## dnd 5e – How can I organize a fight between a main image and a gullible combatant?

Rules as they are written, it seems that what you are trying to do is impossible to do with the main image. In a nutshell, Investigation verification is for observers who do not physically interact with the illusion, and the NPC would immediately notice that something is wrong when its sword crosses the "monk". The description of the spell also covers mundane activities such as walking and talking so that his movements appear natural, but he never mentions combat.

Personally, I would say that such fine control of the illusory monk is not possible with the main image, especially when you control the illusion from an external perspective. To see an example of how difficult this can be, you can watch this video of people playing football / soccer with VR glasses to see from above instead of with their eyes. Keep in mind that these soccer / football players also directly control their own bodies instead of mentally ordering an illusory clone, which intuitively seems to be more difficult.

## Spells that seem to have the desired effect.

Project image (PHB p.270) is a level 7 illusion spell accessible to magicians and bards that allows them to project an illusory clone of themselves up to 500 miles away. As with the main image, the illusion is intangible, and actually dissipates if it receives any damage. However, unlike the main image, the spell allows you to "ride" the illusion, spending an additional action to see through the senses of the illusion.

You can use your action to move this illusion up to twice its speed, and have it gesticulate, speak and behave the way you choose. He imitates his gestures perfectly.

This could be interpreted as the illusion mimics your actual movements, or at least perform the ordered action as you would have done. So mentally you could order him to "dodge", and he would dodge it as best you can. Otherwise, he could argue that his physical body makes the evasion and that the illusion imitates his movements.

All of this is debatable if your DM allows you to really act through the illusion while sharing your senses, however (like a level 7 spell, should be cool and powerful).

As a DM, I would say that if the attack had lost your character (counting only your skill modifier to AC, as a blow to the armor would technically go through the illusion and therefore reveal it as such), then the illusion was also lost, as long as you are sharing your senses and actively trying to avoid attacks. Think of "Luke Skywalker vs. Kylo Ren," except you can not afford a hit.

If your DM is generous, Cheat (PHB p.260) would provide another alternative. As a fifth level spell, it is more easily accessible to players. But unlike the project image, the description of the spell does not really say that the illusion imitates your actions, despite the fact that you can still share your senses to control it. On the positive side, it does not dissipate if it takes damage, but most DMs would probably rule out that it would still reveal it as an illusion.

## Get the monk to cast these spells.

The problem with these two spells, however, is that although they seem to be just what you need, they can only project an image of the caster. As such, you would need a way for the monk to cast it himself if you want your original plan to work.

A spell storage ring (DMG p.193) allows a spellcaster to store up to 5 levels of spells in a ring, which anyone can tune (without the need for spells) to cast the stored spells as if they were the original caster. While this would not work with the project image (level 7 spell), it does work with an error (level 5 spell), as long as your DM accepts the error functions in the way you want it to work.

A scroll spell (DMG p.200) would also allow the monk to cast the spell, as long as you can find a way to get the Project Image in his spell list. A one-level dive in the assistant or bard class, while not exactly efficient for most monks, would work well, as long as they can perform an Intelligence or Charisma test (DC17 or DC15) when casting the spell. To reduce the chances of failure, launch the guide and improve the monk's ability before he tries to read the roll, so that he gets a 1d4 bonus on the roll, as well as an advantage.

Finally, Potions they exist for other illusion spells such as invisibility. If your DM allows you to make your own potions, the party attendant could create an error potion or a project image potion, which the monk could take at the appropriate time. The process to create a potion of this type will depend on your DM, but technically it would be possible.

## Conclusion.

In the end, the most difficult part of this plan (apart from convincing your DM that these spells work the way you want) is to find a way for the monk to cast the necessary spells. However, if you can handle it, I would definitely allow it as a DM, even allowing the monk to add his wisdom modifier to his CA when he "assembles" the illusion, since he technically shares his senses and reacts as if he were there.

If it were your DM, I would definitely allow the project image to work as you plan, but I probably will not cheat, since it does not specify that the spell mimics your mannerism perfectly.

## Synchronization: How to organize the synchronicity reports in a distributed and finally consistent system?

Context: a typical corporate landscape with many systems located in different data centers, with firewalls, without uniformed interface.

Some X data is being replicated for reasons of availability and independence. Let's say that System A is the master system for X.

X is being replicated in the update (event notifications) using various technological means (from the file interface to the API calls) to systems B, C and D.

In order for client-oriented applications to work correctly, we want to make sure that A, B, C, and D are synchronized with each other. Is there a robust mechanism / pattern that can inform if the X versions of these systems are synchronized and highlight any differences?

The main use cases to ensure synchronicity are:

• Periodic report synchronizing the entire customer base to cover any unexpected problems;
• Incidental report for a batch of new clients before opening the applications.

Of particular concern is that I would like the synchronization report to be as simple as possible to avoid false positives or (worst) false negatives.

I could restrict the question even more, but I am also open to reconsidering other parts of the architecture if necessary. However, the distributed nature will be maintained and must be addressed.

NB. As this is my first publication in SE.SE, point out any errors in the label / label / title; I apologize for that I looked for similar questions on this site but I could not find any. This approached however, does not have the answers I need.

## python: How do I organize this code in order to have a menu system that can be nested?

I am a beginner programmer and I have been experimenting with pygame (use python if that is not obvious) through tutorials and so on. I'm stuck because I could not figure out how to make a menu system effective without having to do a lot of looping, if / elif and variable statements. I want to be able to easily create a menu system for my game.

In this current code, I have a class for parents that updates and draws buttons and fonts for the current screen (I have a main screen and a death screen, but they only have two buttons.) These buttons are to exit the game and reach the first level). I check if the buttons are pressed in the main loop and I use the player's object to change the screen.

I would like to know how I could not have to do what I have currently done in the main loop for, say, 4-5 other screens. Can I put a function in the class of screens to check for updates?

Thanks for the contribution you may have!

— Other questions —

Do I need what I did with the font class? How could I get the source incorporated in the class of screens more directly?

/ / / Class to make the start menu and the death screen with the buttons and the source

``````import pygame

BLACK = (0, 0, 0)
WHITE = (255, 255, 255)
RED = (255, 0, 0)
GREEN = (0, 255, 0)
BLUE = (0, 0, 255)
PURPLE = (255, 0, 255)
LIGHT_BLUE = (133, 192, 254)
ORANGE = (255, 155, 0)
LIGHT_GREEN = (79, 154, 97)

Extra_Screens class ():
def __init __ (self):
self.button_options = pygame.sprite.Group ()
self.font_text = pygame.sprite.Group ()

def update (auto):
self.button_options.update ()
self.font_text.update ()

def draw (auto, screen, color):
screen.fill (color)
self.button_options.draw (screen)
self.font_text.draw (screen)

Class Death (Extra_Screens):
def __init __ (self):
super () .__ init __ ()

buttons = [[150, 400, 200, 50, GREEN],
[450, 400, 200, 50, RED]
]texts = [
[175, 407, 50, 'Continue', BLACK],
[510, 407, 50, 'Quit', BLACK],
[210, 250, 80, 'You have died!', BLACK]
]for the element in the buttons:
button_death = Button (item[0], Item[1], Item[2], Item[3], Item[4])
self.button_options.add (button_death)

for the article in the texts:
text_death = Source (item[0], Item[1], Item[2], Item[3], Item[4])
self.font_text.add (text_death)

Main_Menu class (Extra_Screens):
def __init __ (self):
super () .__ init __ ()

buttons = [[150, 400, 200, 50, GREEN],
[450, 400, 200, 50, RED]
]texts = [
[215, 407, 50, 'Play', BLACK],
[510, 407, 50, 'Quit', BLACK],
[210, 250, 80, 'Platformer!', RED],
[210, 320, 35, 'Welcome and Enjoy!', BLUE]
]for the element in the buttons:
button_death = Button (item[0], Item[1], Item[2], Item[3], Item[4])
self.button_options.add (button_death)

for the article in the texts:
text_death = Source (item[0], Item[1], Item[2], Item[3], Item[4])
self.font_text.add (text_death)

Class button (pygame.sprite.Sprite):
def __init __ (self, x, y, width, height, color):
pygame.sprite.Sprite .__ init __ (self)

self.width = width
self.height = height

self.color = color

self.image = pygame.Surface ((width, height))
self.image.fill (color)

self.rect = self.image.get_rect ()

self.rect.x = x
self.rect.y = and

Source of the class (pygame.sprite.Sprite):
def __init __ (self, x, and, size, text, color, font = None):
pygame.sprite.Sprite .__ init __ (self)
self.color = color
self.font = pygame.font.Font (font, size)
self.x = x
self.y = and
self.set (text, x, y)

set of definitions (auto, text, x, y):
self.image = self.font.render (str (text), 1, self.color)
self.rect = self.image.get_rect ()
self.rect.x = x
self.rect.y = and
``````

/ / / Code in the main loop to update the screen when the buttons are clicked

``````                                                yes player.death == True:
if event.type == pygame.MOUSEBUTTONDOWN:
mouse = pygame.mouse.get_pos ()
for the element in death_screen.button_options:
Yes item.color == GREEN and item.rect.x + item.width> mouse[0] > item.rect.x and item.rect.y + item.height> mouse[1] > item.rect.y:
player.rect.y = 200
player.rect.x = 50
player.death = False
break
if item.color == RED and item.rect.x + item.width> mouse[0] > item.rect.x and item.rect.y + item.height> mouse[1] > item.rect.y:
isDone = True

yes player.start == True:
if event.type == pygame.MOUSEBUTTONDOWN:
mouse = pygame.mouse.get_pos ()
for the element in death_screen.button_options:
Yes item.color == GREEN and item.rect.x + item.width> mouse[0] > item.rect.x and item.rect.y + item.height> mouse[1] > item.rect.y:
player.start = False
if item.color == RED and item.rect.x + item.width> mouse[0] > item.rect.x and item.rect.y + item.height> mouse[1] > item.rect.y:
isDone = True
$$`` `$$
``````

## Graphic user interface design: What is a good way to organize hundreds of classifiable elements in a list?

I have many pages of elements, each page contains m x n elements with the dimension designs m and n that the user can edit. I want the order of the elements on the page to be editable, so I thought about using the list of jquery-ui's orderly connections shown here:
https://jqueryui.com/sortable/#connect-lists

Where each page would be a list and the elements can be sorted according to their position in the grid as an array of connected lists. Is this a good approach or should I go in a different direction?

## How to organize the file of family videos? – Everything else

How to organize the file of family videos? Many gigabytes of videos from familiar files have been put together on the hard drive. In the video file not all videos are useful. There are interesting plots. Is it possible to cut out such videos and leave important and interesting details? Is it possible to collect several video files in one?

## Design patterns: how to organize work with objects that contain different qualities of video.

I find a fairly common case of handling video files with different video quality, when the application (in this case on Android) should save and use one or another video file according to the user's choice (global configuration of the application ). I can not find some of the best practices and I think I'm just wasting Google. Anyway, the particular solutions for my example or only the links to related publications will be appreciated.

This is how it works now.

There's a `Media` Object that is stored in db and contains a link to `MediaUrls` Object that has 2 urls: to HD and SD videos. This object comes from a server. For backward compatibility, `Media` object also has a `mediaUrl` Link that is basically the old way of storing the url. Soon:

``````public class media {

@Obsolete
private chain mediaUrl;
MediaUrls private mediaUrls;

// getters, setters, other fields: I like it, views, etc.
}

public class MediaUrls {

Private string hd;
Private string sd;

// getters, setters
}
``````

As a result, we need to have the following logic somewhere to get the actual link:

1. He came back `mediaUrl` in case if there is not `MediaUrls` object

2. Check the configuration in `Preferred Model` Classify and return the SD or HD version based on it.

We can not get the url with only the `Media` Object because we need to know what the current configuration is and we need `Preferred Model` for this. This logic is put into a `MediaRepository` class that has `getVideoUrl (Media)` object. We need that url in many places, as a result, we have to provide the `MediaRepository` in many classes just to get the url for a means of communication.

In other words, if I have `playMedia (media)` Method somewhere, you'll have to call `mdeiaRepository.getVideoUrl (media)` Inside to know which of the urls to play. The same happens with caching and other things.

At the same time, we still want both sd / hd URLs to be present in the `Media` objects, since we can simply use one or the other url without having to update all the other fields of the `Media` object.

The question is what is the way to do it without the need to constantly use a third class to obtain a real URL at this time.

One of the solutions I see is to add smith as `currentUrl` (or reuse existing ones `mediaUrl`) field that will be cached for this purpose and will be rewritten in the background every time the configuration is changed (not very often, that is global in the configuration of the application).

Another could be to add the `Preferred Model` as a dependency of `Media` object, but I'm afraid it will make the latter too "thick".

## javascript – How to organize work with some projects based on shared code?

If not? It depends.

With NPM

Are you already using NPM? Do you have access to an internal NPM packet server? Have you ever used GIT directly for NPM dependencies at home?

• Yes, then do not break the mold. Follow your current pattern.
• No. Then you should consider how you are going to do this.

Technically, NPM supports GIT repositories as packages. However, compatibility with GIT is often interrupted or incomplete compared to an NPM packet server.

NPM Package Servers are not trivial to install, configure or maintain. How do you intend to support them?

No NPM

If you do not want to trust NPM, then your options are:

• git checkout to a subdirectory.
• Copy the package to a local directory and update it manually.

Neither of the two solutions is great. I favor the second only because git's hierarchical checks can be problematic.

However, manual solution requires diligence, especially if there is an implicit link here. Like all projects that need the same appearance, or the communications layer must be identical between projects.

Multiple dependencies

Consider breaking down the shared components further so that only the shared functionality actually required is shared.

Extraction requests

As they would in the main repository of the project.

• Fork
• Make changes
• Push
• Make extraction request

Of course, you must have the diligence, testing and automation to verify / update the subsequent dependencies (or notify the needs / problems).

## combinatorial – organize playdate groups

In my children's school, children meet in playgroups of two girls and two boys each month. The groups are built to obtain so much variation in the groups over the months. After having seen too many cases of any of my children paired with the same one or two months in a row, I set out to do a small program (F #) that would give a list of girls' names and a list of children's names. as a result a list of 4-tuple lists. A tuple of 4 corresponds to a playdate group for four months (one playdate per child per month). Each list of 4 tuples corresponds to a complete set of playdate groups over a period of four months. The list of lists is the smallest set of the set of playdate groups that guarantees "full variation". This proved much more difficult than expected!

I have qualified my expectation of "full variation" in the following requirements:

• In each list of groups, each child is present in exactly one group
• Each child must be in a group of appointments with all other children of the same sex at least once and at most twice
• Each child (girl, resp.) Must be in a group with each girl at least once, but as few times as possible
• For two consecutive lists of groups, the number of children in the same group will be as small as possible.

For a list of children (a, b, c, d) and girls (A, B, C, D), one solution is:
[[(a,b,A,B), (c,d,C,D)],
[(a,c,A,C), (b,d,B,D)],
[(a,d,B,C), (b,c,A,D)],
[(a,b,C,D), (c,d,A,B)]]

This is done entirely by hand and my problem is what a general algorithm would look like. Any ideas?

I have created a function (based on the round-robin algorithm) that, given a list of names, builds the list of 2 unique tuples (for example, for the previous example: [a,b,c,d] -> [(a,b),(a,c),(a,d),(b,c),(b,d),(c,d)]), but I'm not sure if this is useful to solve my problem. The algorithm will eventually verify that each of these combinations matches at least one group, but it is necessary to generate the tuples in advance.

My intention here is completely altruistic! I would like to make a solution that all parents can use for free and the code will be published on GitHub! Any help is really appreciated!!

Thank you
– Thomas